From 8e3485248e5d345c168208770279a33d5f09731a Mon Sep 17 00:00:00 2001 From: Ben Clayton Date: Wed, 1 Jun 2022 15:57:22 +0000 Subject: [PATCH] tint/writer/spirv: Inline constant expressions This is required to handle materialized values, and for constant expressions. Bug: tint:1504 Change-Id: If0a49e9b03566c06aa6e4e4c284fc427e1541e91 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/92082 Reviewed-by: Dan Sinclair Kokoro: Kokoro Commit-Queue: Ben Clayton --- src/tint/writer/spirv/builder.cc | 148 +- src/tint/writer/spirv/builder.h | 6 + .../spirv/builder_accessor_expression_test.cc | 10 +- src/tint/writer/spirv/builder_assign_test.cc | 16 +- .../spirv/builder_binary_expression_test.cc | 10 +- .../spirv/builder_builtin_texture_test.cc | 12 +- .../builder_constructor_expression_test.cc | 1115 +++-- .../spirv/builder_global_variable_test.cc | 17 +- src/tint/writer/spirv/builder_if_test.cc | 10 +- .../spirv/builder_unary_op_expression_test.cc | 2 +- src/tint/writer/spirv/generator_impl.cc | 2 - .../assign_to_subexpr.wgsl.expected.spvasm | 4 +- .../types/runtime_array.wgsl.expected.spvasm | 6 +- .../bug/chromium/1273230.wgsl.expected.spvasm | 478 +- test/tint/bug/dawn/947.wgsl.expected.spvasm | 51 +- .../1112.wgsl.expected.spvasm | 145 +- .../1206.wgsl.expected.spvasm | 4 +- ...local_assign_scalar_x.wgsl.expected.spvasm | 4 +- ...local_assign_scalar_y.wgsl.expected.spvasm | 4 +- ...odule_assign_scalar_x.wgsl.expected.spvasm | 4 +- ...odule_assign_scalar_y.wgsl.expected.spvasm | 4 +- .../loop_call_with_loop.wgsl.expected.spvasm | 105 +- ...oop_call_with_no_loop.wgsl.expected.spvasm | 73 +- .../loop_types_all.wgsl.expected.spvasm | 113 +- .../loop_types_repeated.wgsl.expected.spvasm | 89 +- .../loop_types_some.wgsl.expected.spvasm | 117 +- .../no_loop.wgsl.expected.spvasm | 81 +- test/tint/bug/tint/1046.wgsl.expected.spvasm | 41 +- test/tint/bug/tint/1064.wgsl.expected.spvasm | 4 +- test/tint/bug/tint/1076.wgsl.expected.spvasm | 10 +- test/tint/bug/tint/1081.wgsl.expected.spvasm | 29 +- test/tint/bug/tint/1083.wgsl.expected.spvasm | 4 +- test/tint/bug/tint/1086.wgsl.expected.spvasm | 19 +- .../tint/bug/tint/1088.spvasm.expected.spvasm | 4 +- test/tint/bug/tint/1113.wgsl.expected.spvasm | 409 +- test/tint/bug/tint/1118.wgsl.expected.spvasm | 311 +- test/tint/bug/tint/1121.wgsl.expected.spvasm | 652 ++- test/tint/bug/tint/1369.wgsl.expected.spvasm | 37 +- test/tint/bug/tint/1385.wgsl.expected.spvasm | 4 +- .../tint/bug/tint/1520.spvasm.expected.spvasm | 335 +- test/tint/bug/tint/1541.wgsl.expected.spvasm | 9 +- test/tint/bug/tint/1573.wgsl.expected.spvasm | 2 +- test/tint/bug/tint/221.wgsl.expected.spvasm | 38 +- test/tint/bug/tint/403.wgsl.expected.spvasm | 24 +- test/tint/bug/tint/413.spvasm.expected.spvasm | 8 +- test/tint/bug/tint/453.wgsl.expected.spvasm | 8 +- test/tint/bug/tint/534.wgsl.expected.spvasm | 175 +- test/tint/bug/tint/744.wgsl.expected.spvasm | 10 +- test/tint/bug/tint/749.spvasm.expected.spvasm | 4014 ++++++++--------- test/tint/bug/tint/757.wgsl.expected.spvasm | 42 +- test/tint/bug/tint/764.wgsl.expected.spvasm | 2 +- test/tint/bug/tint/827.wgsl.expected.spvasm | 4 +- test/tint/bug/tint/870.spvasm.expected.spvasm | 45 +- test/tint/bug/tint/913.wgsl.expected.spvasm | 282 +- test/tint/bug/tint/914.wgsl.expected.spvasm | 703 ++- test/tint/bug/tint/922.wgsl.expected.spvasm | 353 +- test/tint/bug/tint/926.wgsl.expected.spvasm | 23 +- test/tint/bug/tint/942.wgsl.expected.spvasm | 139 +- test/tint/bug/tint/943.spvasm.expected.spvasm | 1207 +++-- test/tint/bug/tint/948.wgsl.expected.spvasm | 661 ++- test/tint/bug/tint/949.wgsl.expected.spvasm | 739 ++- test/tint/bug/tint/951.spvasm.expected.spvasm | 69 +- test/tint/bug/tint/977.spvasm.expected.spvasm | 117 +- test/tint/bug/tint/980.wgsl.expected.spvasm | 56 +- test/tint/bug/tint/990.wgsl.expected.spvasm | 4 +- test/tint/bug/tint/992.wgsl.expected.spvasm | 41 +- test/tint/bug/tint/993.wgsl.expected.spvasm | 27 +- test/tint/bug/tint/998.wgsl.expected.spvasm | 5 +- .../scalar/i32.spvasm.expected.spvasm | 32 +- .../scalar/u32.spvasm.expected.spvasm | 29 +- .../vec3/i32.spvasm.expected.spvasm | 25 +- .../vec3/u32.spvasm.expected.spvasm | 25 +- .../208d46.wgsl.expected.spvasm | 109 +- .../6d4656.wgsl.expected.spvasm | 115 +- .../70783f.wgsl.expected.spvasm | 126 +- .../7c38a6.wgsl.expected.spvasm | 132 +- .../858d40.wgsl.expected.spvasm | 132 +- .../ab6345.wgsl.expected.spvasm | 126 +- .../eab32b.wgsl.expected.spvasm | 132 +- .../f70103.wgsl.expected.spvasm | 126 +- .../1ad138.wgsl.expected.spvasm | 134 +- .../1dc84a.wgsl.expected.spvasm | 140 +- .../21e394.wgsl.expected.spvasm | 117 +- .../327c37.wgsl.expected.spvasm | 140 +- .../42fed6.wgsl.expected.spvasm | 123 +- .../8ed26f.wgsl.expected.spvasm | 134 +- .../acfacb.wgsl.expected.spvasm | 140 +- .../d2b4a0.wgsl.expected.spvasm | 134 +- .../000ff3.wgsl.expected.spvasm | 134 +- .../35053e.wgsl.expected.spvasm | 166 +- .../3fd7d0.wgsl.expected.spvasm | 134 +- .../57a1a3.wgsl.expected.spvasm | 126 +- .../6fe804.wgsl.expected.spvasm | 134 +- .../a622c2.wgsl.expected.spvasm | 166 +- .../c1f940.wgsl.expected.spvasm | 166 +- .../f0779d.wgsl.expected.spvasm | 117 +- .../110f2c.wgsl.expected.spvasm | 136 +- .../3a2acc.wgsl.expected.spvasm | 123 +- .../45eb10.wgsl.expected.spvasm | 136 +- .../47d475.wgsl.expected.spvasm | 117 +- .../50c072.wgsl.expected.spvasm | 142 +- .../7496d6.wgsl.expected.spvasm | 142 +- .../86551b.wgsl.expected.spvasm | 142 +- .../cb51ce.wgsl.expected.spvasm | 136 +- .../12c9bb.wgsl.expected.spvasm | 4 +- .../221f22.wgsl.expected.spvasm | 4 +- .../267788.wgsl.expected.spvasm | 4 +- .../26bdfa.wgsl.expected.spvasm | 4 +- .../2efa05.wgsl.expected.spvasm | 4 +- .../2fe1cc.wgsl.expected.spvasm | 4 +- .../50a9ee.wgsl.expected.spvasm | 4 +- .../52045c.wgsl.expected.spvasm | 31 +- .../686ef2.wgsl.expected.spvasm | 4 +- .../72e5d6.wgsl.expected.spvasm | 4 +- .../79df87.wgsl.expected.spvasm | 31 +- .../85d556.wgsl.expected.spvasm | 4 +- .../88ad17.wgsl.expected.spvasm | 4 +- .../9393b0.wgsl.expected.spvasm | 4 +- .../9c9c57.wgsl.expected.spvasm | 4 +- .../a01845.wgsl.expected.spvasm | 4 +- .../a9c9c1.wgsl.expected.spvasm | 4 +- .../b0e16d.wgsl.expected.spvasm | 4 +- .../b3e407.wgsl.expected.spvasm | 31 +- .../d83c45.wgsl.expected.spvasm | 4 +- .../efc8a4.wgsl.expected.spvasm | 4 +- .../f7145b.wgsl.expected.spvasm | 4 +- .../textureLoad/19cf87.wgsl.expected.spvasm | 4 +- .../textureLoad/1b8588.wgsl.expected.spvasm | 4 +- .../textureLoad/1f2016.wgsl.expected.spvasm | 4 +- .../textureLoad/484344.wgsl.expected.spvasm | 4 +- .../textureLoad/4fd803.wgsl.expected.spvasm | 4 +- .../textureLoad/5a2f9d.wgsl.expected.spvasm | 4 +- .../textureLoad/6154d4.wgsl.expected.spvasm | 4 +- .../textureLoad/79e697.wgsl.expected.spvasm | 31 +- .../textureLoad/7c90e5.wgsl.expected.spvasm | 31 +- .../textureLoad/81c381.wgsl.expected.spvasm | 4 +- .../textureLoad/87be85.wgsl.expected.spvasm | 27 +- .../textureLoad/8acf41.wgsl.expected.spvasm | 8 +- .../textureLoad/9b2667.wgsl.expected.spvasm | 27 +- .../textureLoad/a9a9f5.wgsl.expected.spvasm | 4 +- .../textureLoad/c2a480.wgsl.expected.spvasm | 4 +- .../02be59.wgsl.expected.spvasm | 4 +- .../1b0291.wgsl.expected.spvasm | 4 +- .../1bf73e.wgsl.expected.spvasm | 4 +- .../47daa4.wgsl.expected.spvasm | 4 +- .../979816.wgsl.expected.spvasm | 115 +- .../ae5e39.wgsl.expected.spvasm | 4 +- .../ba93b3.wgsl.expected.spvasm | 4 +- .../scalar/i32.spvasm.expected.spvasm | 38 +- .../scalar/u32.spvasm.expected.spvasm | 35 +- .../vec3/i32.spvasm.expected.spvasm | 27 +- .../vec3/u32.spvasm.expected.spvasm | 27 +- .../f32/red.wgsl.expected.spvasm | 4 +- .../i32/red.wgsl.expected.spvasm | 4 +- .../u32/red.wgsl.expected.spvasm | 4 +- .../depth_ms.spvasm.expected.spvasm | 69 +- ...exture_external_param.wgsl.expected.spvasm | 8 +- .../texture_param.wgsl.expected.spvasm | 4 +- .../depth_ms.spvasm.expected.spvasm | 65 +- .../scalar-scalar/bool.wgsl.expected.spvasm | 4 +- .../scalar-scalar/f32.wgsl.expected.spvasm | 4 +- .../scalar-scalar/i32.wgsl.expected.spvasm | 4 +- .../scalar-scalar/u32.wgsl.expected.spvasm | 4 +- .../vec3-scalar/f32.wgsl.expected.spvasm | 4 +- .../vec3-scalar/i32.wgsl.expected.spvasm | 4 +- .../vec3-scalar/u32.wgsl.expected.spvasm | 4 +- .../scalar-scalar/f32.wgsl.expected.spvasm | 13 +- .../scalar-scalar/i32.wgsl.expected.spvasm | 13 +- .../scalar-scalar/u32.wgsl.expected.spvasm | 13 +- .../vec3-scalar/f32.wgsl.expected.spvasm | 21 +- .../vec3-scalar/i32.wgsl.expected.spvasm | 21 +- .../vec3-scalar/u32.wgsl.expected.spvasm | 21 +- .../scalar-scalar/f32.wgsl.expected.spvasm | 11 +- .../scalar-scalar/i32.wgsl.expected.spvasm | 11 +- .../scalar-scalar/u32.wgsl.expected.spvasm | 11 +- .../vec3-scalar/f32.wgsl.expected.spvasm | 19 +- .../vec3-scalar/i32.wgsl.expected.spvasm | 19 +- .../vec3-scalar/u32.wgsl.expected.spvasm | 19 +- .../scalar-scalar/f32.wgsl.expected.spvasm | 4 +- .../scalar-scalar/i32.wgsl.expected.spvasm | 4 +- .../scalar-scalar/u32.wgsl.expected.spvasm | 4 +- .../vec3-scalar/i32.wgsl.expected.spvasm | 4 +- .../vec3-scalar/u32.wgsl.expected.spvasm | 4 +- .../scalar-scalar/f32.wgsl.expected.spvasm | 13 +- .../scalar-scalar/i32.wgsl.expected.spvasm | 13 +- .../scalar-scalar/u32.wgsl.expected.spvasm | 13 +- .../vec3-scalar/i32.wgsl.expected.spvasm | 21 +- .../vec3-scalar/u32.wgsl.expected.spvasm | 21 +- .../scalar-scalar/f32.wgsl.expected.spvasm | 11 +- .../scalar-scalar/i32.wgsl.expected.spvasm | 11 +- .../scalar-scalar/u32.wgsl.expected.spvasm | 11 +- .../vec3-scalar/i32.wgsl.expected.spvasm | 19 +- .../vec3-scalar/u32.wgsl.expected.spvasm | 19 +- .../expression/bool.wgsl.expected.spvasm | 8 +- .../splat/var/bool.wgsl.expected.spvasm | 39 +- .../mat2x2/stride/16.spvasm.expected.spvasm | 21 +- .../let/global/global.wgsl.expected.spvasm | 16 +- .../inferred/function.wgsl.expected.spvasm | 14 +- .../continue_in_switch.wgsl.expected.spvasm | 57 +- .../array/alias.wgsl.expected.spvasm | 4 +- .../array/struct.wgsl.expected.spvasm | 4 +- .../load/global/i32.spvasm.expected.spvasm | 4 +- .../load/local/i32.spvasm.expected.spvasm | 17 +- .../load/param/ptr.spvasm.expected.spvasm | 17 +- .../store/global/i32.spvasm.expected.spvasm | 4 +- .../store/local/i32.spvasm.expected.spvasm | 19 +- .../store/param/ptr.spvasm.expected.spvasm | 15 +- .../compute_boids.wgsl.expected.spvasm | 507 ++- .../simple_vertex.spvasm.expected.spvasm | 28 +- .../samples/triangle.wgsl.expected.spvasm | 2 +- ...agment_input_builtins.wgsl.expected.spvasm | 4 +- ...input_builtins_struct.wgsl.expected.spvasm | 4 +- .../fragment_input_mixed.wgsl.expected.spvasm | 4 +- ...gment_output_builtins.wgsl.expected.spvasm | 4 +- ...utput_builtins_struct.wgsl.expected.spvasm | 4 +- ...fragment_output_mixed.wgsl.expected.spvasm | 13 +- .../in_for_loop_body.wgsl.expected.spvasm | 51 +- ...n_for_loop_continuing.wgsl.expected.spvasm | 51 +- .../in_for_loop_init.wgsl.expected.spvasm | 51 +- .../divide_by_zero.wgsl.expected.spvasm | 50 +- .../decrement/complex.wgsl.expected.spvasm | 4 +- .../decrement/function.wgsl.expected.spvasm | 15 +- .../decrement/private.wgsl.expected.spvasm | 4 +- .../statements/for/basic.wgsl.expected.spvasm | 43 +- .../for/complex.wgsl.expected.spvasm | 61 +- .../condition/array_ctor.wgsl.expected.spvasm | 17 +- .../array_ctor.wgsl.expected.spvasm | 13 +- .../for/continuing/basic.wgsl.expected.spvasm | 4 +- .../struct_ctor.wgsl.expected.spvasm | 43 +- .../statements/for/empty.wgsl.expected.spvasm | 4 +- .../array_ctor.wgsl.expected.spvasm | 31 +- .../initializer/basic.wgsl.expected.spvasm | 33 +- .../struct_ctor.wgsl.expected.spvasm | 4 +- .../for/scoping.wgsl.expected.spvasm | 23 +- .../increment/complex.wgsl.expected.spvasm | 4 +- .../increment/function.wgsl.expected.spvasm | 15 +- .../increment/private.wgsl.expected.spvasm | 4 +- .../type_constructor.wgsl.expected.spvasm | 2 +- .../inferred/function.wgsl.expected.spvasm | 12 +- .../many_workgroup_vars.wgsl.expected.spvasm | 202 +- .../var/uses/private.wgsl.expected.spvasm | 31 +- .../var/uses/workgroup.wgsl.expected.spvasm | 49 +- 242 files changed, 10432 insertions(+), 10031 deletions(-) diff --git a/src/tint/writer/spirv/builder.cc b/src/tint/writer/spirv/builder.cc index 34d550b8eb..18f983af35 100644 --- a/src/tint/writer/spirv/builder.cc +++ b/src/tint/writer/spirv/builder.cc @@ -27,6 +27,7 @@ #include "src/tint/sem/atomic.h" #include "src/tint/sem/builtin.h" #include "src/tint/sem/call.h" +#include "src/tint/sem/constant.h" #include "src/tint/sem/depth_multisampled_texture.h" #include "src/tint/sem/depth_texture.h" #include "src/tint/sem/function.h" @@ -406,6 +407,11 @@ bool Builder::GenerateLabel(uint32_t id) { bool Builder::GenerateAssignStatement(const ast::AssignmentStatement* assign) { if (assign->lhs->Is()) { + if (builder_.Sem().Get(assign->rhs)->ConstantValue()) { + // RHS of phony assignment is constant. + // Constants can't have side-effects, so just drop this. + return true; + } auto rhs_id = GenerateExpression(assign->rhs); if (rhs_id == 0) { return false; @@ -566,8 +572,14 @@ bool Builder::GenerateExecutionModes(const ast::Function* func, uint32_t id) { } uint32_t Builder::GenerateExpression(const ast::Expression* expr) { + if (auto* sem = builder_.Sem().Get(expr)) { + if (auto constant = sem->ConstantValue()) { + return GenerateConstantIfNeeded(constant); + } + } return Switch( - expr, [&](const ast::IndexAccessorExpression* a) { return GenerateAccessorExpression(a); }, + expr, // + [&](const ast::IndexAccessorExpression* a) { return GenerateAccessorExpression(a); }, [&](const ast::BinaryExpression* b) { return GenerateBinaryExpression(b); }, [&](const ast::BitcastExpression* b) { return GenerateBitcastExpression(b); }, [&](const ast::CallExpression* c) { return GenerateCallExpression(c); }, @@ -743,7 +755,15 @@ bool Builder::GenerateGlobalVariable(const ast::Variable* var) { uint32_t init_id = 0; if (var->constructor) { - init_id = GenerateConstructorExpression(var, var->constructor); + if (!var->is_overridable) { + auto* ctor = builder_.Sem().Get(var->constructor); + if (auto constant = ctor->ConstantValue()) { + init_id = GenerateConstantIfNeeded(std::move(constant)); + } + } + if (init_id == 0) { + init_id = GenerateConstructorExpression(var, var->constructor); + } if (init_id == 0) { return false; } @@ -1662,6 +1682,116 @@ uint32_t Builder::GenerateLiteralIfNeeded(const ast::Variable* var, return GenerateConstantIfNeeded(constant); } +uint32_t Builder::GenerateConstantIfNeeded(const sem::Constant& constant) { + if (constant.AllZero()) { + return GenerateConstantNullIfNeeded(constant.Type()); + } + + static constexpr size_t kOpsResultIdx = 1; // operand index of the result + auto& global_scope = scope_stack_[0]; + + auto gen_bool = [&](size_t element_idx) { + bool val = constant.Element(element_idx); + return GenerateConstantIfNeeded(ScalarConstant::Bool(val)); + }; + auto gen_f32 = [&](size_t element_idx) { + auto val = f32(constant.Element(element_idx)); + return GenerateConstantIfNeeded(ScalarConstant::F32(val.value)); + }; + auto gen_i32 = [&](size_t element_idx) { + auto val = i32(constant.Element(element_idx)); + return GenerateConstantIfNeeded(ScalarConstant::I32(val.value)); + }; + auto gen_u32 = [&](size_t element_idx) { + auto val = u32(constant.Element(element_idx)); + return GenerateConstantIfNeeded(ScalarConstant::U32(val.value)); + }; + auto gen_els = [&](std::vector& ids, size_t start, size_t end, auto gen_el) { + for (size_t i = start; i < end; i++) { + auto id = gen_el(i); + if (!id) { + return false; + } + ids.emplace_back(id); + } + return true; + }; + auto gen_vector = [&](const sem::Vector* ty, size_t start, size_t end) -> uint32_t { + auto type_id = GenerateTypeIfNeeded(ty); + if (!type_id) { + return 0; + } + + std::vector ops; + ops.reserve(end - start + 2); + ops.emplace_back(type_id); + ops.push_back(Operand(0u)); // Placeholder for the result ID + auto ok = Switch( + constant.ElementType(), // + [&](const sem::Bool*) { return gen_els(ops, start, end, gen_bool); }, // + [&](const sem::F32*) { return gen_els(ops, start, end, gen_f32); }, // + [&](const sem::I32*) { return gen_els(ops, start, end, gen_i32); }, // + [&](const sem::U32*) { return gen_els(ops, start, end, gen_u32); }, // + [&](Default) { + error_ = "unhandled constant element type: " + builder_.FriendlyName(ty); + return false; + }); + if (!ok) { + return 0; + } + + return utils::GetOrCreate(global_scope.type_ctor_to_id_, OperandListKey{ops}, + [&]() -> uint32_t { + auto result = result_op(); + ops[kOpsResultIdx] = result; + push_type(spv::Op::OpConstantComposite, std::move(ops)); + return std::get(result); + }); + }; + auto gen_matrix = [&](const sem::Matrix* m) -> uint32_t { + auto mat_type_id = GenerateTypeIfNeeded(m); + if (!mat_type_id) { + return 0; + } + + std::vector ops; + ops.reserve(m->columns() + 2); + ops.emplace_back(mat_type_id); + ops.push_back(Operand(0u)); // Placeholder for the result ID + + for (size_t column_idx = 0; column_idx < m->columns(); column_idx++) { + size_t start = m->rows() * column_idx; + size_t end = m->rows() * (column_idx + 1); + auto column_id = gen_vector(m->ColumnType(), start, end); + if (!column_id) { + return 0; + } + ops.emplace_back(column_id); + } + + return utils::GetOrCreate(global_scope.type_ctor_to_id_, OperandListKey{ops}, + [&]() -> uint32_t { + auto result = result_op(); + ops[kOpsResultIdx] = result; + push_type(spv::Op::OpConstantComposite, std::move(ops)); + return std::get(result); + }); + }; + + return Switch( + constant.Type(), // + [&](const sem::Bool*) { return gen_bool(0); }, // + [&](const sem::F32*) { return gen_f32(0); }, // + [&](const sem::I32*) { return gen_i32(0); }, // + [&](const sem::U32*) { return gen_u32(0); }, // + [&](const sem::Vector* v) { return gen_vector(v, 0, constant.ElementCount()); }, // + [&](const sem::Matrix* m) { return gen_matrix(m); }, // + [&](Default) { + error_ = "unhandled constant type: " + builder_.FriendlyName(constant.Type()); + return false; + }); +} + uint32_t Builder::GenerateConstantIfNeeded(const ScalarConstant& constant) { auto it = const_to_id_.find(constant); if (it != const_to_id_.end()) { @@ -2174,12 +2304,7 @@ bool Builder::GenerateBlockStatementWithoutScoping(const ast::BlockStatement* st } uint32_t Builder::GenerateCallExpression(const ast::CallExpression* expr) { - auto* sem = builder_.Sem().Get(expr); - if (auto* m = sem->As()) { - // TODO(crbug.com/tint/1504): Just emit the constant value. - sem = m->Expr(); - } - auto* call = sem->As(); + auto* call = builder_.Sem().Get(expr); auto* target = call->Target(); return Switch( target, [&](const sem::Function* func) { return GenerateFunctionCall(call, func); }, @@ -2936,10 +3061,9 @@ bool Builder::GenerateTextureBuiltin(const sem::Call* call, } spirv_params.emplace_back(gen_arg(Usage::kDepthRef)); - ast::FloatLiteralExpression float_0(ProgramID(), Source{}, 0.0, - ast::FloatLiteralExpression::Suffix::kF); - image_operands.emplace_back(ImageOperand{ - SpvImageOperandsLodMask, Operand(GenerateLiteralIfNeeded(nullptr, &float_0))}); + image_operands.emplace_back( + ImageOperand{SpvImageOperandsLodMask, + Operand(GenerateConstantIfNeeded(ScalarConstant::F32(0.0)))}); break; } default: diff --git a/src/tint/writer/spirv/builder.h b/src/tint/writer/spirv/builder.h index fc2fa13940..9866328a59 100644 --- a/src/tint/writer/spirv/builder.h +++ b/src/tint/writer/spirv/builder.h @@ -43,6 +43,7 @@ // Forward declarations namespace tint::sem { class Call; +class Constant; class Reference; class TypeConstructor; class TypeConversion; @@ -550,6 +551,11 @@ class Builder { /// @param expr the expression const sem::Type* TypeOf(const ast::Expression* expr) const { return builder_.TypeOf(expr); } + /// Generates a constant value if needed + /// @param constant the constant to generate. + /// @returns the ID on success or 0 on failure + uint32_t GenerateConstantIfNeeded(const sem::Constant& constant); + /// Generates a scalar constant if needed /// @param constant the constant to generate. /// @returns the ID on success or 0 on failure diff --git a/src/tint/writer/spirv/builder_accessor_expression_test.cc b/src/tint/writer/spirv/builder_accessor_expression_test.cc index 82fbfd76b6..2df1b6585f 100644 --- a/src/tint/writer/spirv/builder_accessor_expression_test.cc +++ b/src/tint/writer/spirv/builder_accessor_expression_test.cc @@ -326,7 +326,7 @@ TEST_F(BuilderTest, MemberAccessor_NonPointer) { EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 %1 = OpTypeStruct %2 %2 -%3 = OpConstant %2 0 +%3 = OpConstantNull %2 %4 = OpConstantComposite %1 %3 %3 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), @@ -367,7 +367,7 @@ TEST_F(BuilderTest, MemberAccessor_Nested_NonPointer) { EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeFloat 32 %2 = OpTypeStruct %3 %3 %1 = OpTypeStruct %2 -%4 = OpConstant %3 0 +%4 = OpConstantNull %3 %5 = OpConstantComposite %2 %4 %4 %6 = OpConstantComposite %1 %5 )"); @@ -729,7 +729,7 @@ TEST_F(BuilderTest, IndexAccessor_Mixed_ArrayAndMember) { %2 = OpTypePointer Function %3 %13 = OpConstantNull %3 %14 = OpTypeInt 32 1 -%15 = OpConstant %14 0 +%15 = OpConstantNull %14 %16 = OpConstant %10 0 %17 = OpConstant %14 2 %18 = OpTypePointer Function %8 @@ -916,7 +916,7 @@ TEST_F(BuilderTest, IndexAccessor_Array_Literal) { %7 = OpTypeInt 32 0 %8 = OpConstant %7 3 %5 = OpTypeArray %6 %8 -%9 = OpConstant %6 0 +%9 = OpConstantNull %6 %10 = OpConstant %6 0.5 %11 = OpConstant %6 1 %12 = OpConstantComposite %5 %9 %10 %11 @@ -954,7 +954,7 @@ TEST_F(BuilderTest, IndexAccessor_Array_Dynamic) { %7 = OpTypeInt 32 0 %8 = OpConstant %7 3 %5 = OpTypeArray %6 %8 -%9 = OpConstant %6 0 +%9 = OpConstantNull %6 %10 = OpConstant %6 0.5 %11 = OpConstant %6 1 %12 = OpConstantComposite %5 %9 %10 %11 diff --git a/src/tint/writer/spirv/builder_assign_test.cc b/src/tint/writer/spirv/builder_assign_test.cc index 11ac42fee7..71c958c50d 100644 --- a/src/tint/writer/spirv/builder_assign_test.cc +++ b/src/tint/writer/spirv/builder_assign_test.cc @@ -98,7 +98,7 @@ TEST_F(BuilderTest, Assign_Var_ZeroConstructor) { )"); } -TEST_F(BuilderTest, Assign_Var_Complex_ConstructorWithExtract) { +TEST_F(BuilderTest, Assign_Var_Complex_ConstructorNestedVector) { auto* init = vec3(vec2(1_f, 2_f), 3_f); auto* v = Global("var", ty.vec3(), ast::StorageClass::kPrivate); @@ -121,17 +121,13 @@ TEST_F(BuilderTest, Assign_Var_Complex_ConstructorWithExtract) { %2 = OpTypePointer Private %3 %5 = OpConstantNull %3 %1 = OpVariable %2 Private %5 -%6 = OpTypeVector %4 2 -%7 = OpConstant %4 1 -%8 = OpConstant %4 2 -%9 = OpConstantComposite %6 %7 %8 -%12 = OpConstant %4 3 +%6 = OpConstant %4 1 +%7 = OpConstant %4 2 +%8 = OpConstant %4 3 +%9 = OpConstantComposite %3 %6 %7 %8 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%10 = OpCompositeExtract %4 %9 0 -%11 = OpCompositeExtract %4 %9 1 -%13 = OpCompositeConstruct %3 %10 %11 %12 -OpStore %1 %13 + R"(OpStore %1 %9 )"); } diff --git a/src/tint/writer/spirv/builder_binary_expression_test.cc b/src/tint/writer/spirv/builder_binary_expression_test.cc index debe63c460..abaee2e204 100644 --- a/src/tint/writer/spirv/builder_binary_expression_test.cc +++ b/src/tint/writer/spirv/builder_binary_expression_test.cc @@ -264,7 +264,7 @@ TEST_P(BinaryOperatorBoolTest, Scalar) { EXPECT_EQ(b.GenerateBinaryExpression(expr), 4u) << b.error(); EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeBool %2 = OpConstantTrue %1 -%3 = OpConstantFalse %1 +%3 = OpConstantNull %1 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), "%4 = " + param.name + " %1 %2 %3\n"); @@ -724,7 +724,7 @@ TEST_F(BuilderTest, Binary_LogicalAnd_WithLoads) { %3 = OpConstantTrue %2 %5 = OpTypePointer Private %2 %4 = OpVariable %5 Private %3 -%6 = OpConstantFalse %2 +%6 = OpConstantNull %2 %7 = OpVariable %5 Private %6 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), @@ -761,7 +761,7 @@ TEST_F(BuilderTest, Binary_logicalOr_Nested_LogicalAnd) { EXPECT_EQ(b.GenerateBinaryExpression(expr), 10u) << b.error(); EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool %3 = OpConstantTrue %2 -%8 = OpConstantFalse %2 +%8 = OpConstantNull %2 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(%1 = OpLabel @@ -801,7 +801,7 @@ TEST_F(BuilderTest, Binary_logicalAnd_Nested_LogicalOr) { EXPECT_EQ(b.GenerateBinaryExpression(expr), 10u) << b.error(); EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool %3 = OpConstantTrue %2 -%8 = OpConstantFalse %2 +%8 = OpConstantNull %2 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(%1 = OpLabel @@ -877,7 +877,7 @@ TEST_F(BuilderTest, Binary_LogicalOr_WithLoads) { %3 = OpConstantTrue %2 %5 = OpTypePointer Private %2 %4 = OpVariable %5 Private %3 -%6 = OpConstantFalse %2 +%6 = OpConstantNull %2 %7 = OpVariable %5 Private %6 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), diff --git a/src/tint/writer/spirv/builder_builtin_texture_test.cc b/src/tint/writer/spirv/builder_builtin_texture_test.cc index e76e4787fb..b4abfcf141 100644 --- a/src/tint/writer/spirv/builder_builtin_texture_test.cc +++ b/src/tint/writer/spirv/builder_builtin_texture_test.cc @@ -589,7 +589,7 @@ OpCapability ImageQuery %16 = OpConstant %4 2 %17 = OpConstantComposite %14 %15 %16 %18 = OpTypeInt 32 1 -%19 = OpConstant %18 0 +%19 = OpConstantNull %18 )", R"( %10 = OpLoad %7 %5 @@ -615,7 +615,7 @@ OpCapability ImageQuery %16 = OpConstant %4 2 %17 = OpConstantComposite %14 %15 %16 %18 = OpTypeInt 32 1 -%19 = OpConstant %18 0 +%19 = OpConstantNull %18 %20 = OpTypeVector %18 2 %21 = OpConstant %18 3 %22 = OpConstant %18 4 @@ -645,7 +645,7 @@ OpCapability ImageQuery %16 = OpConstant %4 2 %18 = OpTypeInt 32 1 %19 = OpConstant %18 3 -%21 = OpConstant %18 0 +%21 = OpConstantNull %18 )", R"( %10 = OpLoad %7 %5 @@ -673,7 +673,7 @@ OpCapability ImageQuery %16 = OpConstant %4 2 %18 = OpTypeInt 32 1 %19 = OpConstant %18 3 -%21 = OpConstant %18 0 +%21 = OpConstantNull %18 %22 = OpTypeVector %18 2 %23 = OpConstant %18 4 %24 = OpConstant %18 5 @@ -706,7 +706,7 @@ OpCapability ImageQuery %17 = OpConstant %4 3 %18 = OpConstantComposite %14 %15 %16 %17 %19 = OpTypeInt 32 1 -%20 = OpConstant %19 0 +%20 = OpConstantNull %19 )", R"( %10 = OpLoad %7 %5 @@ -732,7 +732,7 @@ OpCapability ImageQuery %16 = OpConstant %4 3 %18 = OpTypeInt 32 1 %19 = OpConstant %18 4 -%21 = OpConstant %18 0 +%21 = OpConstantNull %18 )", R"( %10 = OpLoad %7 %5 diff --git a/src/tint/writer/spirv/builder_constructor_expression_test.cc b/src/tint/writer/spirv/builder_constructor_expression_test.cc index ec69cfbe62..d1fba8fb30 100644 --- a/src/tint/writer/spirv/builder_constructor_expression_test.cc +++ b/src/tint/writer/spirv/builder_constructor_expression_test.cc @@ -36,19 +36,6 @@ TEST_F(SpvBuilderConstructorTest, Const) { )"); } -TEST_F(SpvBuilderConstructorTest, Type_WithCasts_OutsideFunction_IsError) { - auto* t = Construct(Construct(1_i)); - WrapInFunction(t); - - spirv::Builder& b = Build(); - - EXPECT_EQ(b.GenerateExpression(t), 0u); - EXPECT_TRUE(b.has_error()) << b.error(); - EXPECT_EQ(b.error(), - "Internal error: trying to add SPIR-V instruction 124 outside a " - "function"); -} - TEST_F(SpvBuilderConstructorTest, Type) { auto* t = vec3(1_f, 1_f, 3_f); WrapInFunction(t); @@ -74,19 +61,15 @@ TEST_F(SpvBuilderConstructorTest, Type_WithCasts) { b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(t), 7u); + EXPECT_EQ(b.GenerateExpression(t), 4u); ASSERT_FALSE(b.has_error()) << b.error(); EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 %1 = OpTypeVector %2 2 -%4 = OpTypeInt 32 1 -%5 = OpConstant %4 1 -)"); - EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%3 = OpConvertSToF %2 %5 -%6 = OpConvertSToF %2 %5 -%7 = OpCompositeConstruct %1 %3 %6 +%3 = OpConstant %2 1 +%4 = OpConstantComposite %1 %3 %3 )"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); } TEST_F(SpvBuilderConstructorTest, Type_WithAlias) { @@ -100,15 +83,12 @@ TEST_F(SpvBuilderConstructorTest, Type_WithAlias) { spirv::Builder& b = Build(); b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 1u); + EXPECT_EQ(b.GenerateExpression(cast), 2u); - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1 -%3 = OpTypeFloat 32 -%4 = OpConstant %3 2.29999995 -)"); - EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%1 = OpConvertFToS %2 %4 + EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 1 +%2 = OpConstant %1 2 )"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); } TEST_F(SpvBuilderConstructorTest, Type_IdentifierExpression_Param) { @@ -142,26 +122,31 @@ TEST_F(SpvBuilderConstructorTest, Type_IdentifierExpression_Param) { } TEST_F(SpvBuilderConstructorTest, Vector_Bitcast_Params) { - auto* t = vec2(Construct(1_i), Construct(1_i)); - WrapInFunction(t); + auto* var = Var("v", nullptr, vec3(1_f, 2_f, 3_f)); + auto* cast = Bitcast(ty.vec3(), var); + WrapInFunction(var, cast); spirv::Builder& b = Build(); b.push_function(Function{}); + ASSERT_TRUE(b.GenerateFunctionVariable(var)) << b.error(); + ASSERT_EQ(b.GenerateExpression(cast), 10u) << b.error(); - EXPECT_EQ(b.GenerateExpression(t), 7u); - ASSERT_FALSE(b.has_error()) << b.error(); - - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 0 -%1 = OpTypeVector %2 2 -%4 = OpTypeInt 32 1 -%5 = OpConstant %4 1 + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 3 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstant %2 3 +%6 = OpConstantComposite %1 %3 %4 %5 +%8 = OpTypePointer Function %1 +%9 = OpConstantNull %1 +%12 = OpTypeInt 32 0 +%11 = OpTypeVector %12 3 )"); - EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%3 = OpBitcast %2 %5 -%6 = OpBitcast %2 %5 -%7 = OpCompositeConstruct %1 %3 %6 + R"(OpStore %7 %6 +%13 = OpLoad %1 %7 +%10 = OpBitcast %11 %13 )"); } @@ -173,11 +158,11 @@ TEST_F(SpvBuilderConstructorTest, Type_Bool_With_Bool) { b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 3u); + EXPECT_EQ(b.GenerateExpression(cast), 2u); ASSERT_FALSE(b.has_error()) << b.error(); - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool -%3 = OpConstantTrue %2 + EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeBool +%2 = OpConstantTrue %1 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); } @@ -189,10 +174,10 @@ TEST_F(SpvBuilderConstructorTest, Type_I32_With_I32) { spirv::Builder& b = Build(); b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 3u); + EXPECT_EQ(b.GenerateExpression(cast), 2u); - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1 -%3 = OpConstant %2 2 + EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 1 +%2 = OpConstant %1 2 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); } @@ -204,10 +189,10 @@ TEST_F(SpvBuilderConstructorTest, Type_U32_With_U32) { spirv::Builder& b = Build(); b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 3u); + EXPECT_EQ(b.GenerateExpression(cast), 2u); - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 0 -%3 = OpConstant %2 2 + EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 0 +%2 = OpConstant %1 2 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); } @@ -219,10 +204,10 @@ TEST_F(SpvBuilderConstructorTest, Type_F32_With_F32) { spirv::Builder& b = Build(); b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 3u); + EXPECT_EQ(b.GenerateExpression(cast), 2u); - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 -%3 = OpConstant %2 2 + EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32 +%2 = OpConstant %1 2 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); } @@ -285,16 +270,16 @@ TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_F32_Literal) { EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); } -TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_F32_Var) { - auto* var = Var("v", nullptr, Expr(2_f)); - auto* cast = vec2(var); +TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_F32_F32) { + auto* var = Decl(Var("x", ty.f32(), Expr(2_f))); + auto* cast = vec2("x", "x"); WrapInFunction(var, cast); spirv::Builder& b = Build(); b.push_function(Function{}); - ASSERT_TRUE(b.GenerateFunctionVariable(var)) << b.error(); - ASSERT_EQ(b.GenerateExpression(cast), 8u) << b.error(); + EXPECT_TRUE(b.GenerateStatement(var)); + EXPECT_EQ(b.GenerateExpression(cast), 9u); EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32 %2 = OpConstant %1 2 @@ -302,31 +287,16 @@ TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_F32_Var) { %5 = OpConstantNull %1 %6 = OpTypeVector %1 2 )"); - EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpStore %3 %2 + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), + R"(OpStore %3 %2 %7 = OpLoad %1 %3 -%8 = OpCompositeConstruct %6 %7 %7 +%8 = OpLoad %1 %3 +%9 = OpCompositeConstruct %6 %7 %8 )"); } -TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_F32_F32) { - auto* cast = vec2(2_f, 2_f); - WrapInFunction(cast); - - spirv::Builder& b = Build(); - - b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 4u); - - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 -%1 = OpTypeVector %2 2 -%3 = OpConstant %2 2 -%4 = OpConstantComposite %1 %3 %3 -)"); -} - -TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_Vec2) { - auto* value = vec2(2_f, 2_f); - auto* cast = vec2(value); +TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_F32_F32_Const) { + auto* cast = vec2(1_f, 2_f); WrapInFunction(cast); spirv::Builder& b = Build(); @@ -334,109 +304,131 @@ TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_Vec2) { b.push_function(Function{}); EXPECT_EQ(b.GenerateExpression(cast), 5u); - EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeFloat 32 -%2 = OpTypeVector %3 2 -%4 = OpConstant %3 2 -%5 = OpConstantComposite %2 %4 %4 + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 2 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstantComposite %1 %3 %4 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_Vec2) { + auto* var = Decl(Var("x", ty.vec2(), vec2(1_f, 2_f))); + auto* cast = vec2("x"); + WrapInFunction(var, cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_TRUE(b.GenerateStatement(var)); + EXPECT_EQ(b.GenerateExpression(cast), 10u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 2 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstantComposite %1 %3 %4 +%7 = OpTypePointer Function %1 +%8 = OpConstantNull %1 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), + R"(OpStore %6 %5 +%10 = OpLoad %1 %6 +)"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_Vec2_Const) { + auto* cast = vec2(vec2(1_f, 2_f)); + WrapInFunction(cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_EQ(b.GenerateExpression(cast), 5u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 2 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstantComposite %1 %3 %4 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); } TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F32) { - auto* cast = vec3(2_f); + auto* var = Decl(Var("x", ty.f32(), Expr(2_f))); + auto* cast = vec3("x", "x", "x"); + WrapInFunction(var, cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_TRUE(b.GenerateStatement(var)); + EXPECT_EQ(b.GenerateExpression(cast), 10u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32 +%2 = OpConstant %1 2 +%4 = OpTypePointer Function %1 +%5 = OpConstantNull %1 +%6 = OpTypeVector %1 3 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), + R"(OpStore %3 %2 +%7 = OpLoad %1 %3 +%8 = OpLoad %1 %3 +%9 = OpLoad %1 %3 +%10 = OpCompositeConstruct %6 %7 %8 %9 +)"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F32_Const) { + auto* cast = vec3(1_f, 2_f, 3_f); WrapInFunction(cast); spirv::Builder& b = Build(); b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 4u); + EXPECT_EQ(b.GenerateExpression(cast), 6u); EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 %1 = OpTypeVector %2 3 -%3 = OpConstant %2 2 -%4 = OpConstantComposite %1 %3 %3 %3 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstant %2 3 +%6 = OpConstantComposite %1 %3 %4 %5 )"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); } TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_Bool) { - auto* cast = vec3(true); - WrapInFunction(cast); + auto* var = Decl(Var("x", ty.bool_(), Expr(true))); + auto* cast = vec3("x", "x", "x"); + WrapInFunction(var, cast); spirv::Builder& b = Build(); b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 4u); + EXPECT_TRUE(b.GenerateStatement(var)); + EXPECT_EQ(b.GenerateExpression(cast), 10u); - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool -%1 = OpTypeVector %2 3 -%3 = OpConstantTrue %2 -%4 = OpConstantComposite %1 %3 %3 %3 -)"); -} - -TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F32_F32_F32) { - auto* cast = vec3(2_f, 2_f, 2_f); - WrapInFunction(cast); - - spirv::Builder& b = Build(); - - b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 4u); - - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 -%1 = OpTypeVector %2 3 -%3 = OpConstant %2 2 -%4 = OpConstantComposite %1 %3 %3 %3 -)"); -} - -TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F32_Vec2) { - auto* cast = vec3(2_f, vec2(2_f, 2_f)); - WrapInFunction(cast); - - spirv::Builder& b = Build(); - - b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 8u); - - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 -%1 = OpTypeVector %2 3 -%3 = OpConstant %2 2 -%4 = OpTypeVector %2 2 -%5 = OpConstantComposite %4 %3 %3 + EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeBool +%2 = OpConstantTrue %1 +%4 = OpTypePointer Function %1 +%5 = OpConstantNull %1 +%6 = OpTypeVector %1 3 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%6 = OpCompositeExtract %2 %5 0 -%7 = OpCompositeExtract %2 %5 1 -%8 = OpCompositeConstruct %1 %3 %6 %7 + R"(OpStore %3 %2 +%7 = OpLoad %1 %3 +%8 = OpLoad %1 %3 +%9 = OpLoad %1 %3 +%10 = OpCompositeConstruct %6 %7 %8 %9 )"); } -TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_Vec2_F32) { - auto* cast = vec3(vec2(2_f, 2_f), 2_f); - WrapInFunction(cast); - - spirv::Builder& b = Build(); - - b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 8u); - - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 -%1 = OpTypeVector %2 3 -%3 = OpTypeVector %2 2 -%4 = OpConstant %2 2 -%5 = OpConstantComposite %3 %4 %4 -)"); - EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%6 = OpCompositeExtract %2 %5 0 -%7 = OpCompositeExtract %2 %5 1 -%8 = OpCompositeConstruct %1 %6 %7 %4 -)"); -} - -TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_Vec3) { - auto* value = vec3(2_f, 2_f, 2_f); - auto* cast = vec3(value); +TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_Bool_Const) { + auto* cast = vec3(true, false, true); WrapInFunction(cast); spirv::Builder& b = Build(); @@ -444,15 +436,228 @@ TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_Vec3) { b.push_function(Function{}); EXPECT_EQ(b.GenerateExpression(cast), 5u); - EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeFloat 32 -%2 = OpTypeVector %3 3 -%4 = OpConstant %3 2 -%5 = OpConstantComposite %2 %4 %4 %4 + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool +%1 = OpTypeVector %2 3 +%3 = OpConstantTrue %2 +%4 = OpConstantFalse %2 +%5 = OpConstantComposite %1 %3 %4 %3 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F32_F32_F32) { + auto* var = Decl(Var("x", ty.f32(), Expr(2_f))); + auto* cast = vec3("x", "x", "x"); + WrapInFunction(var, cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_TRUE(b.GenerateStatement(var)); + EXPECT_EQ(b.GenerateExpression(cast), 10u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32 +%2 = OpConstant %1 2 +%4 = OpTypePointer Function %1 +%5 = OpConstantNull %1 +%6 = OpTypeVector %1 3 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), + R"(OpStore %3 %2 +%7 = OpLoad %1 %3 +%8 = OpLoad %1 %3 +%9 = OpLoad %1 %3 +%10 = OpCompositeConstruct %6 %7 %8 %9 +)"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F32_F32_F32_Const) { + auto* cast = vec3(1_f, 2_f, 3_f); + WrapInFunction(cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_EQ(b.GenerateExpression(cast), 6u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 3 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstant %2 3 +%6 = OpConstantComposite %1 %3 %4 %5 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F32_Vec2) { + auto* var = Decl(Var("x", ty.vec2(), vec2(2_f, 3_f))); + auto* cast = vec3(1_f, "x"); + WrapInFunction(var, cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_TRUE(b.GenerateStatement(var)); + EXPECT_EQ(b.GenerateExpression(cast), 14u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 2 +%3 = OpConstant %2 2 +%4 = OpConstant %2 3 +%5 = OpConstantComposite %1 %3 %4 +%7 = OpTypePointer Function %1 +%8 = OpConstantNull %1 +%9 = OpTypeVector %2 3 +%10 = OpConstant %2 1 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), + R"(OpStore %6 %5 +%11 = OpLoad %1 %6 +%12 = OpCompositeExtract %2 %11 0 +%13 = OpCompositeExtract %2 %11 1 +%14 = OpCompositeConstruct %9 %10 %12 %13 +)"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F32_Vec2_Const) { + auto* cast = vec3(1_f, vec2(2_f, 3_f)); + WrapInFunction(cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_EQ(b.GenerateExpression(cast), 6u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 3 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstant %2 3 +%6 = OpConstantComposite %1 %3 %4 %5 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_Vec2_F32) { + auto* var = Decl(Var("x", ty.vec2(), vec2(1_f, 2_f))); + auto* cast = vec3("x", 3_f); + WrapInFunction(var, cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_TRUE(b.GenerateStatement(var)); + EXPECT_EQ(b.GenerateExpression(cast), 14u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 2 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstantComposite %1 %3 %4 +%7 = OpTypePointer Function %1 +%8 = OpConstantNull %1 +%9 = OpTypeVector %2 3 +%13 = OpConstant %2 3 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), + R"(OpStore %6 %5 +%10 = OpLoad %1 %6 +%11 = OpCompositeExtract %2 %10 0 +%12 = OpCompositeExtract %2 %10 1 +%14 = OpCompositeConstruct %9 %11 %12 %13 +)"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_Vec2_F32_Const) { + auto* cast = vec3(vec2(1_f, 2_f), 3_f); + WrapInFunction(cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_EQ(b.GenerateExpression(cast), 6u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 3 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstant %2 3 +%6 = OpConstantComposite %1 %3 %4 %5 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_Vec3) { + auto* var = Decl(Var("x", ty.vec3(), vec3(1_f, 2_f, 3_f))); + auto* cast = vec3("x"); + WrapInFunction(var, cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_TRUE(b.GenerateStatement(var)); + EXPECT_EQ(b.GenerateExpression(cast), 11u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 3 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstant %2 3 +%6 = OpConstantComposite %1 %3 %4 %5 +%8 = OpTypePointer Function %1 +%9 = OpConstantNull %1 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), + R"(OpStore %7 %6 +%11 = OpLoad %1 %7 +)"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_Vec3_Const) { + auto* cast = vec3(vec3(1_f, 2_f, 3_f)); + WrapInFunction(cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_EQ(b.GenerateExpression(cast), 6u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 3 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstant %2 3 +%6 = OpConstantComposite %1 %3 %4 %5 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); } TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Bool) { + auto* var = Decl(Var("x", ty.bool_(), Expr(true))); + auto* cast = vec4("x"); + WrapInFunction(var, cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_TRUE(b.GenerateStatement(var)); + EXPECT_EQ(b.GenerateExpression(cast), 8u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeBool +%2 = OpConstantTrue %1 +%4 = OpTypePointer Function %1 +%5 = OpConstantNull %1 +%6 = OpTypeVector %1 4 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), + R"(OpStore %3 %2 +%7 = OpLoad %1 %3 +%8 = OpCompositeConstruct %6 %7 %7 %7 %7 +)"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Bool_Const) { auto* cast = vec4(true); WrapInFunction(cast); @@ -466,9 +671,34 @@ TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Bool) { %3 = OpConstantTrue %2 %4 = OpConstantComposite %1 %3 %3 %3 %3 )"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); } TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32) { + auto* var = Decl(Var("x", ty.f32(), Expr(2_f))); + auto* cast = vec4("x"); + WrapInFunction(var, cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_TRUE(b.GenerateStatement(var)); + EXPECT_EQ(b.GenerateExpression(cast), 8u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32 +%2 = OpConstant %1 2 +%4 = OpTypePointer Function %1 +%5 = OpConstantNull %1 +%6 = OpTypeVector %1 4 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), + R"(OpStore %3 %2 +%7 = OpLoad %1 %3 +%8 = OpCompositeConstruct %6 %7 %7 %7 %7 +)"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_Const) { auto* cast = vec4(2_f); WrapInFunction(cast); @@ -482,10 +712,288 @@ TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32) { %3 = OpConstant %2 2 %4 = OpConstantComposite %1 %3 %3 %3 %3 )"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); } TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_F32_F32_F32) { - auto* cast = vec4(2_f, 2_f, 2_f, 2_f); + auto* var = Decl(Var("x", ty.f32(), Expr(2_f))); + auto* cast = vec4("x", "x", "x", "x"); + WrapInFunction(var, cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_TRUE(b.GenerateStatement(var)); + EXPECT_EQ(b.GenerateExpression(cast), 11u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32 +%2 = OpConstant %1 2 +%4 = OpTypePointer Function %1 +%5 = OpConstantNull %1 +%6 = OpTypeVector %1 4 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), + R"(OpStore %3 %2 +%7 = OpLoad %1 %3 +%8 = OpLoad %1 %3 +%9 = OpLoad %1 %3 +%10 = OpLoad %1 %3 +%11 = OpCompositeConstruct %6 %7 %8 %9 %10 +)"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_F32_F32_F32_Const) { + auto* cast = vec4(1_f, 2_f, 3_f, 4_f); + WrapInFunction(cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_EQ(b.GenerateExpression(cast), 7u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 4 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstant %2 3 +%6 = OpConstant %2 4 +%7 = OpConstantComposite %1 %3 %4 %5 %6 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_F32_Vec2) { + auto* var = Decl(Var("x", ty.vec2(), vec2(1_f, 2_f))); + auto* cast = vec4(1_f, 2_f, "x"); + WrapInFunction(var, cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_TRUE(b.GenerateStatement(var)); + EXPECT_EQ(b.GenerateExpression(cast), 13u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 2 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstantComposite %1 %3 %4 +%7 = OpTypePointer Function %1 +%8 = OpConstantNull %1 +%9 = OpTypeVector %2 4 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), + R"(OpStore %6 %5 +%10 = OpLoad %1 %6 +%11 = OpCompositeExtract %2 %10 0 +%12 = OpCompositeExtract %2 %10 1 +%13 = OpCompositeConstruct %9 %3 %4 %11 %12 +)"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_F32_Vec2_Const) { + auto* cast = vec4(1_f, 2_f, vec2(3_f, 4_f)); + WrapInFunction(cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_EQ(b.GenerateExpression(cast), 7u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 4 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstant %2 3 +%6 = OpConstant %2 4 +%7 = OpConstantComposite %1 %3 %4 %5 %6 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_Vec2_F32) { + auto* var = Decl(Var("x", ty.vec2(), vec2(2_f, 3_f))); + auto* cast = vec4(1_f, "x", 4_f); + WrapInFunction(var, cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_TRUE(b.GenerateStatement(var)); + EXPECT_EQ(b.GenerateExpression(cast), 15u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 2 +%3 = OpConstant %2 2 +%4 = OpConstant %2 3 +%5 = OpConstantComposite %1 %3 %4 +%7 = OpTypePointer Function %1 +%8 = OpConstantNull %1 +%9 = OpTypeVector %2 4 +%10 = OpConstant %2 1 +%14 = OpConstant %2 4 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), + R"(OpStore %6 %5 +%11 = OpLoad %1 %6 +%12 = OpCompositeExtract %2 %11 0 +%13 = OpCompositeExtract %2 %11 1 +%15 = OpCompositeConstruct %9 %10 %12 %13 %14 +)"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_Vec2_F32_Const) { + auto* cast = vec4(1_f, vec2(2_f, 3_f), 4_f); + WrapInFunction(cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_EQ(b.GenerateExpression(cast), 7u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 4 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstant %2 3 +%6 = OpConstant %2 4 +%7 = OpConstantComposite %1 %3 %4 %5 %6 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec2_F32_F32) { + auto* var = Decl(Var("x", ty.vec2(), vec2(1_f, 2_f))); + auto* cast = vec4("x", 3_f, 4_f); + WrapInFunction(var, cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_TRUE(b.GenerateStatement(var)); + EXPECT_EQ(b.GenerateExpression(cast), 15u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 2 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstantComposite %1 %3 %4 +%7 = OpTypePointer Function %1 +%8 = OpConstantNull %1 +%9 = OpTypeVector %2 4 +%13 = OpConstant %2 3 +%14 = OpConstant %2 4 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), + R"(OpStore %6 %5 +%10 = OpLoad %1 %6 +%11 = OpCompositeExtract %2 %10 0 +%12 = OpCompositeExtract %2 %10 1 +%15 = OpCompositeConstruct %9 %11 %12 %13 %14 +)"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec2_F32_F32_Const) { + auto* cast = vec4(vec2(1_f, 2_f), 3_f, 4_f); + WrapInFunction(cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_EQ(b.GenerateExpression(cast), 7u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 4 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstant %2 3 +%6 = OpConstant %2 4 +%7 = OpConstantComposite %1 %3 %4 %5 %6 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec2_Vec2) { + auto* var = Decl(Var("x", ty.vec2(), vec2(1_f, 2_f))); + auto* cast = vec4("x", "x"); + WrapInFunction(var, cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_TRUE(b.GenerateStatement(var)); + EXPECT_EQ(b.GenerateExpression(cast), 16u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 2 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstantComposite %1 %3 %4 +%7 = OpTypePointer Function %1 +%8 = OpConstantNull %1 +%9 = OpTypeVector %2 4 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), + R"(OpStore %6 %5 +%10 = OpLoad %1 %6 +%11 = OpCompositeExtract %2 %10 0 +%12 = OpCompositeExtract %2 %10 1 +%13 = OpLoad %1 %6 +%14 = OpCompositeExtract %2 %13 0 +%15 = OpCompositeExtract %2 %13 1 +%16 = OpCompositeConstruct %9 %11 %12 %14 %15 +)"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec2_Vec2_Const) { + auto* cast = vec4(vec2(1_f, 2_f), vec2(1_f, 2_f)); + WrapInFunction(cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_EQ(b.GenerateExpression(cast), 5u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 4 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstantComposite %1 %3 %4 %3 %4 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_Vec3) { + auto* var = Decl(Var("x", ty.vec3(), vec3(2_f, 2_f, 2_f))); + auto* cast = vec4(2_f, "x"); + WrapInFunction(var, cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_TRUE(b.GenerateStatement(var)); + EXPECT_EQ(b.GenerateExpression(cast), 13u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 3 +%3 = OpConstant %2 2 +%4 = OpConstantComposite %1 %3 %3 %3 +%6 = OpTypePointer Function %1 +%7 = OpConstantNull %1 +%8 = OpTypeVector %2 4 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), + R"(OpStore %5 %4 +%9 = OpLoad %1 %5 +%10 = OpCompositeExtract %2 %9 0 +%11 = OpCompositeExtract %2 %9 1 +%12 = OpCompositeExtract %2 %9 2 +%13 = OpCompositeConstruct %8 %3 %10 %11 %12 +)"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_Vec3_Const) { + auto* cast = vec4(2_f, vec3(2_f, 2_f, 2_f)); WrapInFunction(cast); spirv::Builder& b = Build(); @@ -498,142 +1006,53 @@ TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_F32_F32_F32) { %3 = OpConstant %2 2 %4 = OpConstantComposite %1 %3 %3 %3 %3 )"); -} - -TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_F32_Vec2) { - auto* cast = vec4(2_f, 2_f, vec2(2_f, 2_f)); - WrapInFunction(cast); - - spirv::Builder& b = Build(); - - b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 8u); - - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 -%1 = OpTypeVector %2 4 -%3 = OpConstant %2 2 -%4 = OpTypeVector %2 2 -%5 = OpConstantComposite %4 %3 %3 -)"); - EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%6 = OpCompositeExtract %2 %5 0 -%7 = OpCompositeExtract %2 %5 1 -%8 = OpCompositeConstruct %1 %3 %3 %6 %7 -)"); -} - -TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_Vec2_F32) { - auto* cast = vec4(2_f, vec2(2_f, 2_f), 2_f); - WrapInFunction(cast); - - spirv::Builder& b = Build(); - - b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 8u); - - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 -%1 = OpTypeVector %2 4 -%3 = OpConstant %2 2 -%4 = OpTypeVector %2 2 -%5 = OpConstantComposite %4 %3 %3 -)"); - EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%6 = OpCompositeExtract %2 %5 0 -%7 = OpCompositeExtract %2 %5 1 -%8 = OpCompositeConstruct %1 %3 %6 %7 %3 -)"); -} - -TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec2_F32_F32) { - auto* cast = vec4(vec2(2_f, 2_f), 2_f, 2_f); - WrapInFunction(cast); - - spirv::Builder& b = Build(); - - b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 8u); - - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 -%1 = OpTypeVector %2 4 -%3 = OpTypeVector %2 2 -%4 = OpConstant %2 2 -%5 = OpConstantComposite %3 %4 %4 -)"); - EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%6 = OpCompositeExtract %2 %5 0 -%7 = OpCompositeExtract %2 %5 1 -%8 = OpCompositeConstruct %1 %6 %7 %4 %4 -)"); -} - -TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec2_Vec2) { - auto* cast = vec4(vec2(2_f, 2_f), vec2(2_f, 2_f)); - WrapInFunction(cast); - - spirv::Builder& b = Build(); - - b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 10u); - - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 -%1 = OpTypeVector %2 4 -%3 = OpTypeVector %2 2 -%4 = OpConstant %2 2 -%5 = OpConstantComposite %3 %4 %4 -)"); - EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%6 = OpCompositeExtract %2 %5 0 -%7 = OpCompositeExtract %2 %5 1 -%8 = OpCompositeExtract %2 %5 0 -%9 = OpCompositeExtract %2 %5 1 -%10 = OpCompositeConstruct %1 %6 %7 %8 %9 -)"); -} - -TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_Vec3) { - auto* cast = vec4(2_f, vec3(2_f, 2_f, 2_f)); - WrapInFunction(cast); - - spirv::Builder& b = Build(); - - b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 9u); - - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 -%1 = OpTypeVector %2 4 -%3 = OpConstant %2 2 -%4 = OpTypeVector %2 3 -%5 = OpConstantComposite %4 %3 %3 %3 -)"); - EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%6 = OpCompositeExtract %2 %5 0 -%7 = OpCompositeExtract %2 %5 1 -%8 = OpCompositeExtract %2 %5 2 -%9 = OpCompositeConstruct %1 %3 %6 %7 %8 -)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); } TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec3_F32) { + auto* var = Decl(Var("x", ty.vec3(), vec3(2_f, 2_f, 2_f))); + auto* cast = vec4("x", 2_f); + WrapInFunction(var, cast); + + spirv::Builder& b = Build(); + + b.push_function(Function{}); + EXPECT_TRUE(b.GenerateStatement(var)); + EXPECT_EQ(b.GenerateExpression(cast), 13u); + + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 3 +%3 = OpConstant %2 2 +%4 = OpConstantComposite %1 %3 %3 %3 +%6 = OpTypePointer Function %1 +%7 = OpConstantNull %1 +%8 = OpTypeVector %2 4 +)"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), + R"(OpStore %5 %4 +%9 = OpLoad %1 %5 +%10 = OpCompositeExtract %2 %9 0 +%11 = OpCompositeExtract %2 %9 1 +%12 = OpCompositeExtract %2 %9 2 +%13 = OpCompositeConstruct %8 %10 %11 %12 %3 +)"); +} + +TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec3_F32_Const) { auto* cast = vec4(vec3(2_f, 2_f, 2_f), 2_f); WrapInFunction(cast); spirv::Builder& b = Build(); b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 9u); + EXPECT_EQ(b.GenerateExpression(cast), 4u); EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 %1 = OpTypeVector %2 4 -%3 = OpTypeVector %2 3 -%4 = OpConstant %2 2 -%5 = OpConstantComposite %3 %4 %4 %4 -)"); - EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%6 = OpCompositeExtract %2 %5 0 -%7 = OpCompositeExtract %2 %5 1 -%8 = OpCompositeExtract %2 %5 2 -%9 = OpCompositeConstruct %1 %6 %7 %8 %4 +%3 = OpConstant %2 2 +%4 = OpConstantComposite %1 %3 %3 %3 %3 )"); + EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); } TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec4) { @@ -644,12 +1063,12 @@ TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec4) { spirv::Builder& b = Build(); b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 5u); + EXPECT_EQ(b.GenerateExpression(cast), 4u); - EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeFloat 32 -%2 = OpTypeVector %3 4 -%4 = OpConstant %3 2 -%5 = OpConstantComposite %2 %4 %4 %4 %4 + EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 +%1 = OpTypeVector %2 4 +%3 = OpConstant %2 2 +%4 = OpConstantComposite %1 %3 %3 %3 %3 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); } @@ -1427,110 +1846,146 @@ TEST_F(SpvBuilderConstructorTest, Type_ZeroInit_Struct) { } TEST_F(SpvBuilderConstructorTest, Type_Convert_U32_To_I32) { - auto* cast = Construct(2_u); - WrapInFunction(cast); + auto* var = Decl(Var("x", ty.u32(), Expr(2_u))); + auto* cast = Construct("x"); + WrapInFunction(var, cast); spirv::Builder& b = Build(); b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 1u); + EXPECT_TRUE(b.GenerateStatement(var)) << b.error(); + EXPECT_EQ(b.GenerateExpression(cast), 6u) << b.error(); - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1 -%3 = OpTypeInt 32 0 -%4 = OpConstant %3 2 + EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 0 +%2 = OpConstant %1 2 +%4 = OpTypePointer Function %1 +%5 = OpConstantNull %1 +%7 = OpTypeInt 32 1 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%1 = OpBitcast %2 %4 + R"(OpStore %3 %2 +%8 = OpLoad %1 %3 +%6 = OpBitcast %7 %8 )"); } TEST_F(SpvBuilderConstructorTest, Type_Convert_I32_To_U32) { - auto* cast = Construct(2_i); - WrapInFunction(cast); + auto* var = Decl(Var("x", ty.i32(), Expr(2_i))); + auto* cast = Construct("x"); + WrapInFunction(var, cast); spirv::Builder& b = Build(); b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 1u); + EXPECT_TRUE(b.GenerateStatement(var)) << b.error(); + EXPECT_EQ(b.GenerateExpression(cast), 6u) << b.error(); - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 0 -%3 = OpTypeInt 32 1 -%4 = OpConstant %3 2 + EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 1 +%2 = OpConstant %1 2 +%4 = OpTypePointer Function %1 +%5 = OpConstantNull %1 +%7 = OpTypeInt 32 0 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%1 = OpBitcast %2 %4 + R"(OpStore %3 %2 +%8 = OpLoad %1 %3 +%6 = OpBitcast %7 %8 )"); } TEST_F(SpvBuilderConstructorTest, Type_Convert_F32_To_I32) { - auto* cast = Construct(2.4_f); - WrapInFunction(cast); + auto* var = Decl(Var("x", ty.f32(), Expr(2.4_f))); + auto* cast = Construct("x"); + WrapInFunction(var, cast); spirv::Builder& b = Build(); b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 1u); + EXPECT_TRUE(b.GenerateStatement(var)) << b.error(); + EXPECT_EQ(b.GenerateExpression(cast), 6u) << b.error(); - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1 -%3 = OpTypeFloat 32 -%4 = OpConstant %3 2.4000001 + EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32 +%2 = OpConstant %1 2.4000001 +%4 = OpTypePointer Function %1 +%5 = OpConstantNull %1 +%7 = OpTypeInt 32 1 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%1 = OpConvertFToS %2 %4 + R"(OpStore %3 %2 +%8 = OpLoad %1 %3 +%6 = OpConvertFToS %7 %8 )"); } TEST_F(SpvBuilderConstructorTest, Type_Convert_F32_To_U32) { - auto* cast = Construct(2.4_f); - WrapInFunction(cast); + auto* var = Decl(Var("x", ty.f32(), Expr(2.4_f))); + auto* cast = Construct("x"); + WrapInFunction(var, cast); spirv::Builder& b = Build(); b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 1u); + EXPECT_TRUE(b.GenerateStatement(var)) << b.error(); + EXPECT_EQ(b.GenerateExpression(cast), 6u) << b.error(); - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 0 -%3 = OpTypeFloat 32 -%4 = OpConstant %3 2.4000001 + EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32 +%2 = OpConstant %1 2.4000001 +%4 = OpTypePointer Function %1 +%5 = OpConstantNull %1 +%7 = OpTypeInt 32 0 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%1 = OpConvertFToU %2 %4 + R"(OpStore %3 %2 +%8 = OpLoad %1 %3 +%6 = OpConvertFToU %7 %8 )"); } TEST_F(SpvBuilderConstructorTest, Type_Convert_I32_To_F32) { - auto* cast = Construct(2_i); - WrapInFunction(cast); + auto* var = Decl(Var("x", ty.i32(), Expr(2_i))); + auto* cast = Construct("x"); + WrapInFunction(var, cast); spirv::Builder& b = Build(); b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 1u); + EXPECT_TRUE(b.GenerateStatement(var)) << b.error(); + EXPECT_EQ(b.GenerateExpression(cast), 6u) << b.error(); - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 -%3 = OpTypeInt 32 1 -%4 = OpConstant %3 2 + EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 1 +%2 = OpConstant %1 2 +%4 = OpTypePointer Function %1 +%5 = OpConstantNull %1 +%7 = OpTypeFloat 32 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%1 = OpConvertSToF %2 %4 + R"(OpStore %3 %2 +%8 = OpLoad %1 %3 +%6 = OpConvertSToF %7 %8 )"); } TEST_F(SpvBuilderConstructorTest, Type_Convert_U32_To_F32) { - auto* cast = Construct(2_u); - WrapInFunction(cast); + auto* var = Decl(Var("x", ty.u32(), Expr(2_u))); + auto* cast = Construct("x"); + WrapInFunction(var, cast); spirv::Builder& b = Build(); b.push_function(Function{}); - EXPECT_EQ(b.GenerateExpression(cast), 1u); + EXPECT_TRUE(b.GenerateStatement(var)) << b.error(); + EXPECT_EQ(b.GenerateExpression(cast), 6u) << b.error(); - EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 -%3 = OpTypeInt 32 0 -%4 = OpConstant %3 2 + EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 0 +%2 = OpConstant %1 2 +%4 = OpTypePointer Function %1 +%5 = OpConstantNull %1 +%7 = OpTypeFloat 32 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), - R"(%1 = OpConvertUToF %2 %4 + R"(OpStore %3 %2 +%8 = OpLoad %1 %3 +%6 = OpConvertUToF %7 %8 )"); } diff --git a/src/tint/writer/spirv/builder_global_variable_test.cc b/src/tint/writer/spirv/builder_global_variable_test.cc index 249c048838..9b30bb168a 100644 --- a/src/tint/writer/spirv/builder_global_variable_test.cc +++ b/src/tint/writer/spirv/builder_global_variable_test.cc @@ -100,7 +100,7 @@ TEST_F(BuilderTest, GlobalVar_Complex_Constructor) { )"); } -TEST_F(BuilderTest, GlobalVar_Complex_ConstructorWithExtract) { +TEST_F(BuilderTest, GlobalVar_Complex_ConstructorNestedVector) { auto* init = vec3(vec2(1_f, 2_f), 3_f); auto* v = GlobalConst("var", ty.vec3(), init); @@ -112,17 +112,10 @@ TEST_F(BuilderTest, GlobalVar_Complex_ConstructorWithExtract) { EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 %1 = OpTypeVector %2 3 -%3 = OpTypeVector %2 2 -%4 = OpConstant %2 1 -%5 = OpConstant %2 2 -%6 = OpConstantComposite %3 %4 %5 -%8 = OpTypeInt 32 0 -%9 = OpConstant %8 0 -%7 = OpSpecConstantOp %2 CompositeExtract %6 9 -%11 = OpConstant %8 1 -%10 = OpSpecConstantOp %2 CompositeExtract %6 11 -%12 = OpConstant %2 3 -%13 = OpSpecConstantComposite %1 %7 %10 %12 +%3 = OpConstant %2 1 +%4 = OpConstant %2 2 +%5 = OpConstant %2 3 +%6 = OpConstantComposite %1 %3 %4 %5 )"); } diff --git a/src/tint/writer/spirv/builder_if_test.cc b/src/tint/writer/spirv/builder_if_test.cc index a32f409036..8c7c8eef0f 100644 --- a/src/tint/writer/spirv/builder_if_test.cc +++ b/src/tint/writer/spirv/builder_if_test.cc @@ -223,7 +223,7 @@ TEST_F(BuilderTest, If_WithMultiple) { %6 = OpConstantTrue %5 %10 = OpConstant %3 2 %14 = OpConstant %3 3 -%15 = OpConstantFalse %5 +%15 = OpConstantNull %5 %19 = OpConstant %3 4 %20 = OpConstant %3 5 )"); @@ -472,7 +472,7 @@ TEST_F(BuilderTest, If_WithReturnValue) { EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool %1 = OpTypeFunction %2 %5 = OpConstantTrue %2 -%8 = OpConstantFalse %2 +%8 = OpConstantNull %2 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpSelectionMerge %6 None @@ -542,7 +542,7 @@ TEST_F(BuilderTest, If_WithNestedBlockReturnValue) { EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool %1 = OpTypeFunction %2 %5 = OpConstantTrue %2 -%8 = OpConstantFalse %2 +%8 = OpConstantNull %2 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpSelectionMerge %6 None @@ -600,7 +600,7 @@ TEST_F(BuilderTest, If_ElseIf_WithReturn) { EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid %1 = OpTypeFunction %2 %5 = OpTypeBool -%6 = OpConstantFalse %5 +%6 = OpConstantNull %5 %10 = OpConstantTrue %5 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), @@ -638,7 +638,7 @@ TEST_F(BuilderTest, Loop_If_ElseIf_WithBreak) { EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid %1 = OpTypeFunction %2 %9 = OpTypeBool -%10 = OpConstantFalse %9 +%10 = OpConstantNull %9 %14 = OpConstantTrue %9 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), diff --git a/src/tint/writer/spirv/builder_unary_op_expression_test.cc b/src/tint/writer/spirv/builder_unary_op_expression_test.cc index fa8082809e..e28eb78fa5 100644 --- a/src/tint/writer/spirv/builder_unary_op_expression_test.cc +++ b/src/tint/writer/spirv/builder_unary_op_expression_test.cc @@ -79,7 +79,7 @@ TEST_F(BuilderTest, UnaryOp_Not) { b.push_function(Function{}); EXPECT_EQ(b.GenerateUnaryOpExpression(expr), 1u) << b.error(); EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool -%3 = OpConstantFalse %2 +%3 = OpConstantNull %2 )"); EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(%1 = OpLogicalNot %2 %3 diff --git a/src/tint/writer/spirv/generator_impl.cc b/src/tint/writer/spirv/generator_impl.cc index 21216bf467..b8ca89c4b1 100644 --- a/src/tint/writer/spirv/generator_impl.cc +++ b/src/tint/writer/spirv/generator_impl.cc @@ -23,7 +23,6 @@ #include "src/tint/transform/canonicalize_entry_point_io.h" #include "src/tint/transform/disable_uniformity_analysis.h" #include "src/tint/transform/expand_compound_assignment.h" -#include "src/tint/transform/fold_constants.h" #include "src/tint/transform/for_loop_to_loop.h" #include "src/tint/transform/manager.h" #include "src/tint/transform/promote_side_effects_to_decl.h" @@ -73,7 +72,6 @@ SanitizedResult Sanitize(const Program* in, const Options& options) { manager.Add(); manager.Add(); manager.Add(); // Required for arrayLength() - manager.Add(); manager.Add(); manager.Add(); // Must come after // ZeroInitWorkgroupMemory diff --git a/test/tint/array/assign_to_subexpr.wgsl.expected.spvasm b/test/tint/array/assign_to_subexpr.wgsl.expected.spvasm index d234c75650..c6ba3d6000 100644 --- a/test/tint/array/assign_to_subexpr.wgsl.expected.spvasm +++ b/test/tint/array/assign_to_subexpr.wgsl.expected.spvasm @@ -34,7 +34,7 @@ %22 = OpConstantNull %_arr__arr_int_uint_4_uint_2 %uint_0 = OpConstant %uint 0 %int_1 = OpConstant %int 1 - %int_0 = OpConstant %int 0 + %28 = OpConstantNull %int %unused_entry_point = OpFunction %void None %1 %4 = OpLabel OpReturn @@ -51,7 +51,7 @@ OpStore %dst %11 %27 = OpAccessChain %_ptr_Function__arr_int_uint_4 %dst_struct %uint_0 OpStore %27 %11 - %29 = OpAccessChain %_ptr_Function__arr_int_uint_4 %dst_array %int_0 + %29 = OpAccessChain %_ptr_Function__arr_int_uint_4 %dst_array %28 OpStore %29 %11 OpReturn OpFunctionEnd diff --git a/test/tint/buffer/storage/types/runtime_array.wgsl.expected.spvasm b/test/tint/buffer/storage/types/runtime_array.wgsl.expected.spvasm index 5a63e67be4..8fbc2cae04 100644 --- a/test/tint/buffer/storage/types/runtime_array.wgsl.expected.spvasm +++ b/test/tint/buffer/storage/types/runtime_array.wgsl.expected.spvasm @@ -35,12 +35,12 @@ %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %15 = OpConstantNull %int %_ptr_StorageBuffer_S = OpTypePointer StorageBuffer %S %main = OpFunction %void None %8 %11 = OpLabel - %17 = OpAccessChain %_ptr_StorageBuffer_S %out %uint_0 %int_0 - %18 = OpAccessChain %_ptr_StorageBuffer_S %in %uint_0 %int_0 + %17 = OpAccessChain %_ptr_StorageBuffer_S %out %uint_0 %15 + %18 = OpAccessChain %_ptr_StorageBuffer_S %in %uint_0 %15 %19 = OpLoad %S %18 OpStore %17 %19 OpReturn diff --git a/test/tint/bug/chromium/1273230.wgsl.expected.spvasm b/test/tint/bug/chromium/1273230.wgsl.expected.spvasm index 71068d20c3..8a5f8fb0a4 100644 --- a/test/tint/bug/chromium/1273230.wgsl.expected.spvasm +++ b/test/tint/bug/chromium/1273230.wgsl.expected.spvasm @@ -1,10 +1,10 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 277 +; Bound: 273 ; Schema: 0 OpCapability Shader - %71 = OpExtInstImport "GLSL.std.450" + %67 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main_count "main_count" %GlobalInvocationID_1 OpExecutionMode %main_count LocalSize 128 1 1 @@ -165,37 +165,33 @@ %dbg = OpVariable %_ptr_StorageBuffer_Dbg StorageBuffer %void = OpTypeVoid %30 = OpTypeFunction %void - %int_0 = OpConstant %int 0 - %v4float = OpTypeVector %float 4 - %float_2 = OpConstant %float 2 - %37 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 - %38 = OpTypeFunction %v3float %v3float + %34 = OpTypeFunction %v3float %v3float %uint_4 = OpConstant %uint 4 %uint_0 = OpConstant %uint 0 %_ptr_Uniform_float = OpTypePointer Uniform %float %uint_1 = OpConstant %uint 1 %uint_2 = OpConstant %uint 2 %_ptr_Function_v3float = OpTypePointer Function %v3float - %56 = OpConstantNull %v3float + %52 = OpConstantNull %v3float %uint_5 = OpConstant %uint 5 %_ptr_Function_float = OpTypePointer Function %float - %81 = OpConstantNull %float + %77 = OpConstantNull %float %_ptr_Uniform_uint = OpTypePointer Uniform %uint - %118 = OpTypeFunction %uint %uint %v3float + %114 = OpTypeFunction %uint %uint %v3float %_ptr_Function_v3uint = OpTypePointer Function %v3uint - %126 = OpConstantNull %v3uint + %122 = OpConstantNull %v3uint %_ptr_Function_uint = OpTypePointer Function %uint - %139 = OpTypeFunction %v3uint %uint %uint - %147 = OpConstantNull %uint - %160 = OpTypeFunction %v3float %uint + %135 = OpTypeFunction %v3uint %uint %uint + %143 = OpConstantNull %uint + %156 = OpTypeFunction %v3float %uint %uint_3 = OpConstant %uint 3 %_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint + %188 = OpConstantNull %int %_ptr_StorageBuffer_uint_0 = OpTypePointer StorageBuffer %uint %_ptr_StorageBuffer_int = OpTypePointer StorageBuffer %int %_ptr_Function_int = OpTypePointer Function %int - %207 = OpConstantNull %int - %208 = OpTypeFunction %void %v3uint + %204 = OpTypeFunction %void %v3uint %bool = OpTypeBool %float_3 = OpConstant %float 3 %int_1 = OpConstant %int 1 @@ -203,255 +199,255 @@ %33 = OpLabel OpReturn OpFunctionEnd - %toVoxelPos = OpFunction %v3float None %38 + %toVoxelPos = OpFunction %v3float None %34 %position = OpFunctionParameter %v3float - %41 = OpLabel - %bbMin = OpVariable %_ptr_Function_v3float Function %56 - %bbMax = OpVariable %_ptr_Function_v3float Function %56 - %bbSize = OpVariable %_ptr_Function_v3float Function %56 - %cubeSize = OpVariable %_ptr_Function_float Function %81 - %gridSize = OpVariable %_ptr_Function_float Function %81 - %gx = OpVariable %_ptr_Function_float Function %81 - %gy = OpVariable %_ptr_Function_float Function %81 - %gz = OpVariable %_ptr_Function_float Function %81 - %45 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_4 %uint_0 - %46 = OpLoad %float %45 - %48 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_4 %uint_1 - %49 = OpLoad %float %48 - %51 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_4 %uint_2 - %52 = OpLoad %float %51 - %53 = OpCompositeConstruct %v3float %46 %49 %52 - OpStore %bbMin %53 - %58 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_5 %uint_0 + %37 = OpLabel + %bbMin = OpVariable %_ptr_Function_v3float Function %52 + %bbMax = OpVariable %_ptr_Function_v3float Function %52 + %bbSize = OpVariable %_ptr_Function_v3float Function %52 + %cubeSize = OpVariable %_ptr_Function_float Function %77 + %gridSize = OpVariable %_ptr_Function_float Function %77 + %gx = OpVariable %_ptr_Function_float Function %77 + %gy = OpVariable %_ptr_Function_float Function %77 + %gz = OpVariable %_ptr_Function_float Function %77 + %41 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_4 %uint_0 + %42 = OpLoad %float %41 + %44 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_4 %uint_1 + %45 = OpLoad %float %44 + %47 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_4 %uint_2 + %48 = OpLoad %float %47 + %49 = OpCompositeConstruct %v3float %42 %45 %48 + OpStore %bbMin %49 + %54 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_5 %uint_0 + %55 = OpLoad %float %54 + %56 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_5 %uint_1 + %57 = OpLoad %float %56 + %58 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_5 %uint_2 %59 = OpLoad %float %58 - %60 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_5 %uint_1 - %61 = OpLoad %float %60 - %62 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_5 %uint_2 - %63 = OpLoad %float %62 - %64 = OpCompositeConstruct %v3float %59 %61 %63 - OpStore %bbMax %64 - %66 = OpLoad %v3float %bbMin - %67 = OpLoad %v3float %bbMin - %68 = OpFSub %v3float %66 %67 - OpStore %bbSize %68 - %74 = OpAccessChain %_ptr_Function_float %bbMax %uint_0 + %60 = OpCompositeConstruct %v3float %55 %57 %59 + OpStore %bbMax %60 + %62 = OpLoad %v3float %bbMin + %63 = OpLoad %v3float %bbMin + %64 = OpFSub %v3float %62 %63 + OpStore %bbSize %64 + %70 = OpAccessChain %_ptr_Function_float %bbMax %uint_0 + %71 = OpLoad %float %70 + %72 = OpAccessChain %_ptr_Function_float %bbMax %uint_1 + %73 = OpLoad %float %72 + %68 = OpExtInst %float %67 NMax %71 %73 + %74 = OpAccessChain %_ptr_Function_float %bbSize %uint_2 %75 = OpLoad %float %74 - %76 = OpAccessChain %_ptr_Function_float %bbMax %uint_1 - %77 = OpLoad %float %76 - %72 = OpExtInst %float %71 NMax %75 %77 - %78 = OpAccessChain %_ptr_Function_float %bbSize %uint_2 - %79 = OpLoad %float %78 - %70 = OpExtInst %float %71 NMax %72 %79 - OpStore %cubeSize %70 - %84 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 - %85 = OpLoad %uint %84 - %82 = OpConvertUToF %float %85 - OpStore %gridSize %82 - %87 = OpLoad %float %cubeSize - %88 = OpCompositeExtract %float %position 0 - %89 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_4 %uint_0 - %90 = OpLoad %float %89 - %91 = OpFSub %float %88 %90 - %92 = OpFMul %float %87 %91 - %93 = OpLoad %float %cubeSize - %94 = OpFDiv %float %92 %93 - OpStore %gx %94 - %96 = OpLoad %float %gx - %97 = OpCompositeExtract %float %position 1 - %98 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_4 %uint_1 - %99 = OpLoad %float %98 - %100 = OpFSub %float %97 %99 - %101 = OpFMul %float %96 %100 - %102 = OpLoad %float %gridSize - %103 = OpFDiv %float %101 %102 - OpStore %gy %103 - %105 = OpLoad %float %gridSize - %106 = OpCompositeExtract %float %position 2 - %107 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_4 %uint_2 - %108 = OpLoad %float %107 - %109 = OpFSub %float %106 %108 - %110 = OpFMul %float %105 %109 - %111 = OpLoad %float %gridSize - %112 = OpFDiv %float %110 %111 - OpStore %gz %112 - %114 = OpLoad %float %gz - %115 = OpLoad %float %gz - %116 = OpLoad %float %gz - %117 = OpCompositeConstruct %v3float %114 %115 %116 - OpReturnValue %117 + %66 = OpExtInst %float %67 NMax %68 %75 + OpStore %cubeSize %66 + %80 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 + %81 = OpLoad %uint %80 + %78 = OpConvertUToF %float %81 + OpStore %gridSize %78 + %83 = OpLoad %float %cubeSize + %84 = OpCompositeExtract %float %position 0 + %85 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_4 %uint_0 + %86 = OpLoad %float %85 + %87 = OpFSub %float %84 %86 + %88 = OpFMul %float %83 %87 + %89 = OpLoad %float %cubeSize + %90 = OpFDiv %float %88 %89 + OpStore %gx %90 + %92 = OpLoad %float %gx + %93 = OpCompositeExtract %float %position 1 + %94 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_4 %uint_1 + %95 = OpLoad %float %94 + %96 = OpFSub %float %93 %95 + %97 = OpFMul %float %92 %96 + %98 = OpLoad %float %gridSize + %99 = OpFDiv %float %97 %98 + OpStore %gy %99 + %101 = OpLoad %float %gridSize + %102 = OpCompositeExtract %float %position 2 + %103 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_4 %uint_2 + %104 = OpLoad %float %103 + %105 = OpFSub %float %102 %104 + %106 = OpFMul %float %101 %105 + %107 = OpLoad %float %gridSize + %108 = OpFDiv %float %106 %107 + OpStore %gz %108 + %110 = OpLoad %float %gz + %111 = OpLoad %float %gz + %112 = OpLoad %float %gz + %113 = OpCompositeConstruct %v3float %110 %111 %112 + OpReturnValue %113 OpFunctionEnd - %toIndex1D = OpFunction %uint None %118 + %toIndex1D = OpFunction %uint None %114 %gridSize_0 = OpFunctionParameter %uint %voxelPos = OpFunctionParameter %v3float - %122 = OpLabel - %icoord = OpVariable %_ptr_Function_v3uint Function %126 - %123 = OpConvertFToU %v3uint %voxelPos - OpStore %icoord %123 - %128 = OpAccessChain %_ptr_Function_uint %icoord %uint_0 - %129 = OpLoad %uint %128 - %130 = OpAccessChain %_ptr_Function_uint %icoord %uint_1 - %131 = OpLoad %uint %130 - %132 = OpIMul %uint %gridSize_0 %131 - %133 = OpIAdd %uint %129 %132 - %134 = OpIMul %uint %gridSize_0 %gridSize_0 - %135 = OpAccessChain %_ptr_Function_uint %icoord %uint_2 - %136 = OpLoad %uint %135 - %137 = OpIMul %uint %134 %136 - %138 = OpIAdd %uint %133 %137 - OpReturnValue %138 + %118 = OpLabel + %icoord = OpVariable %_ptr_Function_v3uint Function %122 + %119 = OpConvertFToU %v3uint %voxelPos + OpStore %icoord %119 + %124 = OpAccessChain %_ptr_Function_uint %icoord %uint_0 + %125 = OpLoad %uint %124 + %126 = OpAccessChain %_ptr_Function_uint %icoord %uint_1 + %127 = OpLoad %uint %126 + %128 = OpIMul %uint %gridSize_0 %127 + %129 = OpIAdd %uint %125 %128 + %130 = OpIMul %uint %gridSize_0 %gridSize_0 + %131 = OpAccessChain %_ptr_Function_uint %icoord %uint_2 + %132 = OpLoad %uint %131 + %133 = OpIMul %uint %130 %132 + %134 = OpIAdd %uint %129 %133 + OpReturnValue %134 OpFunctionEnd - %toIndex4D = OpFunction %v3uint None %139 + %toIndex4D = OpFunction %v3uint None %135 %gridSize_1 = OpFunctionParameter %uint %index = OpFunctionParameter %uint - %143 = OpLabel - %z = OpVariable %_ptr_Function_uint Function %147 - %y = OpVariable %_ptr_Function_uint Function %147 - %x = OpVariable %_ptr_Function_uint Function %147 - %144 = OpIMul %uint %index %index - %145 = OpUDiv %uint %gridSize_1 %144 - OpStore %z %145 - %148 = OpIMul %uint %gridSize_1 %gridSize_1 - %149 = OpLoad %uint %z - %150 = OpIMul %uint %148 %149 - %151 = OpISub %uint %gridSize_1 %150 - %152 = OpUDiv %uint %151 %gridSize_1 - OpStore %y %152 - %154 = OpUMod %uint %index %gridSize_1 - OpStore %x %154 - %156 = OpLoad %uint %z - %157 = OpLoad %uint %y - %158 = OpLoad %uint %y - %159 = OpCompositeConstruct %v3uint %156 %157 %158 - OpReturnValue %159 + %139 = OpLabel + %z = OpVariable %_ptr_Function_uint Function %143 + %y = OpVariable %_ptr_Function_uint Function %143 + %x = OpVariable %_ptr_Function_uint Function %143 + %140 = OpIMul %uint %index %index + %141 = OpUDiv %uint %gridSize_1 %140 + OpStore %z %141 + %144 = OpIMul %uint %gridSize_1 %gridSize_1 + %145 = OpLoad %uint %z + %146 = OpIMul %uint %144 %145 + %147 = OpISub %uint %gridSize_1 %146 + %148 = OpUDiv %uint %147 %gridSize_1 + OpStore %y %148 + %150 = OpUMod %uint %index %gridSize_1 + OpStore %x %150 + %152 = OpLoad %uint %z + %153 = OpLoad %uint %y + %154 = OpLoad %uint %y + %155 = OpCompositeConstruct %v3uint %152 %153 %154 + OpReturnValue %155 OpFunctionEnd -%loadPosition = OpFunction %v3float None %160 +%loadPosition = OpFunction %v3float None %156 %vertexIndex = OpFunctionParameter %uint - %163 = OpLabel - %position_0 = OpVariable %_ptr_Function_v3float Function %56 - %165 = OpIMul %uint %uint_3 %vertexIndex - %166 = OpIAdd %uint %165 %uint_0 - %168 = OpAccessChain %_ptr_StorageBuffer_float %positions %uint_0 %166 + %159 = OpLabel + %position_0 = OpVariable %_ptr_Function_v3float Function %52 + %161 = OpIMul %uint %uint_3 %vertexIndex + %162 = OpIAdd %uint %161 %143 + %164 = OpAccessChain %_ptr_StorageBuffer_float %positions %uint_0 %162 + %165 = OpLoad %float %164 + %166 = OpIMul %uint %uint_3 %vertexIndex + %167 = OpIAdd %uint %166 %uint_1 + %168 = OpAccessChain %_ptr_StorageBuffer_float %positions %uint_0 %167 %169 = OpLoad %float %168 %170 = OpIMul %uint %uint_3 %vertexIndex - %171 = OpIAdd %uint %170 %uint_1 + %171 = OpIAdd %uint %170 %uint_2 %172 = OpAccessChain %_ptr_StorageBuffer_float %positions %uint_0 %171 %173 = OpLoad %float %172 - %174 = OpIMul %uint %uint_3 %vertexIndex - %175 = OpIAdd %uint %174 %uint_2 - %176 = OpAccessChain %_ptr_StorageBuffer_float %positions %uint_0 %175 - %177 = OpLoad %float %176 - %178 = OpCompositeConstruct %v3float %169 %173 %177 - OpStore %position_0 %178 - %180 = OpLoad %v3float %position_0 - OpReturnValue %180 + %174 = OpCompositeConstruct %v3float %165 %169 %173 + OpStore %position_0 %174 + %176 = OpLoad %v3float %position_0 + OpReturnValue %176 OpFunctionEnd %doIgnore = OpFunction %void None %30 - %182 = OpLabel - %g43 = OpVariable %_ptr_Function_uint Function %147 - %kj6 = OpVariable %_ptr_Function_uint Function %147 - %b53 = OpVariable %_ptr_Function_uint Function %147 - %rwg = OpVariable %_ptr_Function_uint Function %147 - %rb5 = OpVariable %_ptr_Function_float Function %81 - %g55 = OpVariable %_ptr_Function_int Function %207 - %183 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 + %178 = OpLabel + %g43 = OpVariable %_ptr_Function_uint Function %143 + %kj6 = OpVariable %_ptr_Function_uint Function %143 + %b53 = OpVariable %_ptr_Function_uint Function %143 + %rwg = OpVariable %_ptr_Function_uint Function %143 + %rb5 = OpVariable %_ptr_Function_float Function %77 + %g55 = OpVariable %_ptr_Function_int Function %188 + %179 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 + %180 = OpLoad %uint %179 + OpStore %g43 %180 + %183 = OpAccessChain %_ptr_StorageBuffer_uint %dbg %uint_5 %184 = OpLoad %uint %183 - OpStore %g43 %184 - %187 = OpAccessChain %_ptr_StorageBuffer_uint %dbg %uint_5 - %188 = OpLoad %uint %187 - OpStore %kj6 %188 - %193 = OpAccessChain %_ptr_StorageBuffer_uint_0 %counters %uint_0 %int_0 - %190 = OpAtomicLoad %uint %193 %uint_1 %uint_0 - OpStore %b53 %190 - %195 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %int_0 - %196 = OpLoad %uint %195 - OpStore %rwg %196 - %198 = OpAccessChain %_ptr_StorageBuffer_float %positions %uint_0 %int_0 - %199 = OpLoad %float %198 - OpStore %rb5 %199 - %204 = OpAccessChain %_ptr_StorageBuffer_int %LUT %uint_0 %int_0 - %201 = OpAtomicLoad %int %204 %uint_1 %uint_0 - OpStore %g55 %201 + OpStore %kj6 %184 + %190 = OpAccessChain %_ptr_StorageBuffer_uint_0 %counters %uint_0 %188 + %186 = OpAtomicLoad %uint %190 %uint_1 %uint_0 + OpStore %b53 %186 + %192 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %188 + %193 = OpLoad %uint %192 + OpStore %rwg %193 + %195 = OpAccessChain %_ptr_StorageBuffer_float %positions %uint_0 %188 + %196 = OpLoad %float %195 + OpStore %rb5 %196 + %201 = OpAccessChain %_ptr_StorageBuffer_int %LUT %uint_0 %188 + %198 = OpAtomicLoad %int %201 %uint_1 %uint_0 + OpStore %g55 %198 OpReturn OpFunctionEnd -%main_count_inner = OpFunction %void None %208 +%main_count_inner = OpFunction %void None %204 %GlobalInvocationID = OpFunctionParameter %v3uint - %211 = OpLabel -%triangleIndex = OpVariable %_ptr_Function_uint Function %147 - %i0 = OpVariable %_ptr_Function_uint Function %147 - %i1 = OpVariable %_ptr_Function_uint Function %147 - %i2 = OpVariable %_ptr_Function_uint Function %147 - %p0 = OpVariable %_ptr_Function_v3float Function %56 - %p1 = OpVariable %_ptr_Function_v3float Function %56 - %p2 = OpVariable %_ptr_Function_v3float Function %56 - %256 = OpVariable %_ptr_Function_v3float Function %56 - %center = OpVariable %_ptr_Function_v3float Function %56 - %voxelPos_0 = OpVariable %_ptr_Function_v3float Function %56 - %lIndex = OpVariable %_ptr_Function_uint Function %147 -%triangleOffset = OpVariable %_ptr_Function_int Function %207 - %212 = OpCompositeExtract %uint %GlobalInvocationID 0 - OpStore %triangleIndex %212 - %214 = OpLoad %uint %triangleIndex - %215 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 - %216 = OpLoad %uint %215 - %217 = OpUGreaterThanEqual %bool %214 %216 - OpSelectionMerge %219 None - OpBranchConditional %217 %220 %219 - %220 = OpLabel + %207 = OpLabel +%triangleIndex = OpVariable %_ptr_Function_uint Function %143 + %i0 = OpVariable %_ptr_Function_uint Function %143 + %i1 = OpVariable %_ptr_Function_uint Function %143 + %i2 = OpVariable %_ptr_Function_uint Function %143 + %p0 = OpVariable %_ptr_Function_v3float Function %52 + %p1 = OpVariable %_ptr_Function_v3float Function %52 + %p2 = OpVariable %_ptr_Function_v3float Function %52 + %252 = OpVariable %_ptr_Function_v3float Function %52 + %center = OpVariable %_ptr_Function_v3float Function %52 + %voxelPos_0 = OpVariable %_ptr_Function_v3float Function %52 + %lIndex = OpVariable %_ptr_Function_uint Function %143 +%triangleOffset = OpVariable %_ptr_Function_int Function %188 + %208 = OpCompositeExtract %uint %GlobalInvocationID 0 + OpStore %triangleIndex %208 + %210 = OpLoad %uint %triangleIndex + %211 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 + %212 = OpLoad %uint %211 + %213 = OpUGreaterThanEqual %bool %210 %212 + OpSelectionMerge %215 None + OpBranchConditional %213 %216 %215 + %216 = OpLabel OpReturn - %219 = OpLabel - %221 = OpFunctionCall %void %doIgnore - %222 = OpLoad %uint %triangleIndex - %223 = OpIMul %uint %uint_3 %222 - %224 = OpIAdd %uint %223 %uint_0 - %225 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %224 - %226 = OpLoad %uint %225 - OpStore %i0 %226 - %228 = OpLoad %uint %i0 - %229 = OpIMul %uint %uint_3 %228 - %230 = OpIAdd %uint %229 %uint_1 - %231 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %230 - %232 = OpLoad %uint %231 - OpStore %i1 %232 - %234 = OpLoad %uint %i0 - %235 = OpIMul %uint %uint_3 %234 - %236 = OpIAdd %uint %235 %uint_2 - %237 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %236 - %238 = OpLoad %uint %237 - OpStore %i2 %238 - %241 = OpLoad %uint %i0 - %240 = OpFunctionCall %v3float %loadPosition %241 - OpStore %p0 %240 - %244 = OpLoad %uint %i0 - %243 = OpFunctionCall %v3float %loadPosition %244 - OpStore %p1 %243 - %247 = OpLoad %uint %i2 - %246 = OpFunctionCall %v3float %loadPosition %247 - OpStore %p2 %246 - %249 = OpLoad %v3float %p0 - %250 = OpLoad %v3float %p2 - %251 = OpFAdd %v3float %249 %250 - %252 = OpLoad %v3float %p1 - %253 = OpFAdd %v3float %251 %252 - %257 = OpCompositeConstruct %v3float %float_3 %float_3 %float_3 - %255 = OpFDiv %v3float %253 %257 - OpStore %center %255 - %260 = OpLoad %v3float %p1 - %259 = OpFunctionCall %v3float %toVoxelPos %260 - OpStore %voxelPos_0 %259 - %263 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 - %264 = OpLoad %uint %263 - %265 = OpLoad %v3float %p0 - %262 = OpFunctionCall %uint %toIndex1D %264 %265 - OpStore %lIndex %262 - %269 = OpLoad %uint %i1 - %270 = OpAccessChain %_ptr_StorageBuffer_int %LUT %uint_0 %269 - %267 = OpAtomicIAdd %int %270 %uint_1 %uint_0 %int_1 - OpStore %triangleOffset %267 + %215 = OpLabel + %217 = OpFunctionCall %void %doIgnore + %218 = OpLoad %uint %triangleIndex + %219 = OpIMul %uint %uint_3 %218 + %220 = OpIAdd %uint %219 %143 + %221 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %220 + %222 = OpLoad %uint %221 + OpStore %i0 %222 + %224 = OpLoad %uint %i0 + %225 = OpIMul %uint %uint_3 %224 + %226 = OpIAdd %uint %225 %uint_1 + %227 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %226 + %228 = OpLoad %uint %227 + OpStore %i1 %228 + %230 = OpLoad %uint %i0 + %231 = OpIMul %uint %uint_3 %230 + %232 = OpIAdd %uint %231 %uint_2 + %233 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %232 + %234 = OpLoad %uint %233 + OpStore %i2 %234 + %237 = OpLoad %uint %i0 + %236 = OpFunctionCall %v3float %loadPosition %237 + OpStore %p0 %236 + %240 = OpLoad %uint %i0 + %239 = OpFunctionCall %v3float %loadPosition %240 + OpStore %p1 %239 + %243 = OpLoad %uint %i2 + %242 = OpFunctionCall %v3float %loadPosition %243 + OpStore %p2 %242 + %245 = OpLoad %v3float %p0 + %246 = OpLoad %v3float %p2 + %247 = OpFAdd %v3float %245 %246 + %248 = OpLoad %v3float %p1 + %249 = OpFAdd %v3float %247 %248 + %253 = OpCompositeConstruct %v3float %float_3 %float_3 %float_3 + %251 = OpFDiv %v3float %249 %253 + OpStore %center %251 + %256 = OpLoad %v3float %p1 + %255 = OpFunctionCall %v3float %toVoxelPos %256 + OpStore %voxelPos_0 %255 + %259 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 + %260 = OpLoad %uint %259 + %261 = OpLoad %v3float %p0 + %258 = OpFunctionCall %uint %toIndex1D %260 %261 + OpStore %lIndex %258 + %265 = OpLoad %uint %i1 + %266 = OpAccessChain %_ptr_StorageBuffer_int %LUT %uint_0 %265 + %263 = OpAtomicIAdd %int %266 %uint_1 %uint_0 %int_1 + OpStore %triangleOffset %263 OpReturn OpFunctionEnd %main_count = OpFunction %void None %30 - %274 = OpLabel - %276 = OpLoad %v3uint %GlobalInvocationID_1 - %275 = OpFunctionCall %void %main_count_inner %276 + %270 = OpLabel + %272 = OpLoad %v3uint %GlobalInvocationID_1 + %271 = OpFunctionCall %void %main_count_inner %272 OpReturn OpFunctionEnd diff --git a/test/tint/bug/dawn/947.wgsl.expected.spvasm b/test/tint/bug/dawn/947.wgsl.expected.spvasm index d98acc3e7e..8e5c56c412 100644 --- a/test/tint/bug/dawn/947.wgsl.expected.spvasm +++ b/test/tint/bug/dawn/947.wgsl.expected.spvasm @@ -13,7 +13,7 @@ bug/dawn/947.wgsl:55:33 note: reading from user-defined input 'texcoord' may res ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 140 +; Bound: 139 ; Schema: 0 OpCapability Shader %118 = OpExtInstImport "GLSL.std.450" @@ -128,9 +128,8 @@ bug/dawn/947.wgsl:55:33 note: reading from user-defined input 'texcoord' may res %void = OpTypeVoid %103 = OpTypeFunction %void %113 = OpTypeFunction %v4float %v2float - %119 = OpConstantComposite %v2float %float_0 %float_0 %v2bool = OpTypeVector %bool 2 - %132 = OpTypeSampledImage %27 + %131 = OpTypeSampledImage %27 %vs_main_inner = OpFunction %VertexOutputs None %28 %VertexIndex = OpFunctionParameter %uint %32 = OpLabel @@ -145,11 +144,11 @@ bug/dawn/947.wgsl:55:33 note: reading from user-defined input 'texcoord' may res %59 = OpFSub %v2float %56 %58 %60 = OpCompositeExtract %float %59 0 %61 = OpCompositeExtract %float %59 1 - %62 = OpCompositeConstruct %v4float %60 %61 %float_0 %float_1 + %62 = OpCompositeConstruct %v4float %60 %61 %15 %float_1 OpStore %52 %62 %65 = OpAccessChain %_ptr_Uniform_float %uniforms %uint_0 %uint_1 %66 = OpLoad %float %65 - %67 = OpFOrdLessThan %bool %66 %float_0 + %67 = OpFOrdLessThan %bool %66 %15 OpStore %flipY %67 %72 = OpLoad %bool %flipY OpSelectionMerge %73 None @@ -206,30 +205,30 @@ bug/dawn/947.wgsl:55:33 note: reading from user-defined input 'texcoord' may res %116 = OpLabel %clampedTexcoord = OpVariable %_ptr_Function_v2float Function %8 %srcColor = OpVariable %_ptr_Function_v4float Function %12 - %117 = OpExtInst %v2float %118 NClamp %texcoord_0 %119 %58 + %117 = OpExtInst %v2float %118 NClamp %texcoord_0 %8 %58 OpStore %clampedTexcoord %117 - %123 = OpLoad %v2float %clampedTexcoord - %124 = OpFOrdEqual %v2bool %123 %texcoord_0 - %122 = OpAll %bool %124 - %121 = OpLogicalNot %bool %122 - OpSelectionMerge %126 None - OpBranchConditional %121 %127 %126 - %127 = OpLabel - %128 = OpFunctionCall %void %tint_discard_func - OpReturnValue %12 + %122 = OpLoad %v2float %clampedTexcoord + %123 = OpFOrdEqual %v2bool %122 %texcoord_0 + %121 = OpAll %bool %123 + %120 = OpLogicalNot %bool %121 + OpSelectionMerge %125 None + OpBranchConditional %120 %126 %125 %126 = OpLabel - %130 = OpLoad %24 %mySampler - %131 = OpLoad %27 %myTexture - %133 = OpSampledImage %132 %131 %130 - %129 = OpImageSampleImplicitLod %v4float %133 %texcoord_0 - OpStore %srcColor %129 - %135 = OpLoad %v4float %srcColor - OpReturnValue %135 + %127 = OpFunctionCall %void %tint_discard_func + OpReturnValue %12 + %125 = OpLabel + %129 = OpLoad %24 %mySampler + %130 = OpLoad %27 %myTexture + %132 = OpSampledImage %131 %130 %129 + %128 = OpImageSampleImplicitLod %v4float %132 %texcoord_0 + OpStore %srcColor %128 + %134 = OpLoad %v4float %srcColor + OpReturnValue %134 OpFunctionEnd %fs_main = OpFunction %void None %103 - %137 = OpLabel - %139 = OpLoad %v2float %texcoord_1 - %138 = OpFunctionCall %v4float %fs_main_inner %139 - OpStore %value %138 + %136 = OpLabel + %138 = OpLoad %v2float %texcoord_1 + %137 = OpFunctionCall %v4float %fs_main_inner %138 + OpStore %value %137 OpReturn OpFunctionEnd diff --git a/test/tint/bug/fxc/gradient_in_varying_loop/1112.wgsl.expected.spvasm b/test/tint/bug/fxc/gradient_in_varying_loop/1112.wgsl.expected.spvasm index 79e45a61ad..42fde31b2d 100644 --- a/test/tint/bug/fxc/gradient_in_varying_loop/1112.wgsl.expected.spvasm +++ b/test/tint/bug/fxc/gradient_in_varying_loop/1112.wgsl.expected.spvasm @@ -13,7 +13,7 @@ bug/fxc/gradient_in_varying_loop/1112.wgsl:8:29 note: return value of 'textureSa ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 83 +; Bound: 82 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -55,95 +55,94 @@ bug/fxc/gradient_in_varying_loop/1112.wgsl:8:29 note: return value of 'textureSa %23 = OpTypeSampledImage %14 %v3float = OpTypeVector %float 3 %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %28 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %31 = OpConstantNull %int %int_1 = OpConstant %int 1 %bool = OpTypeBool - %float_0 = OpConstant %float 0 + %45 = OpConstantNull %float %float_1 = OpConstant %float 1 - %76 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 + %75 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %void = OpTypeVoid - %77 = OpTypeFunction %void + %76 = OpTypeFunction %void %main_inner = OpFunction %v4float None %16 %vUV = OpFunctionParameter %v2float %19 = OpLabel - %i = OpVariable %_ptr_Function_int Function %31 + %i = OpVariable %_ptr_Function_int Function %28 %21 = OpLoad %11 %Sampler %22 = OpLoad %14 %randomTexture %24 = OpSampledImage %23 %22 %21 %20 = OpImageSampleImplicitLod %v4float %24 %vUV %26 = OpVectorShuffle %v3float %20 %20 0 1 2 - OpStore %i %int_0 - OpBranch %32 - %32 = OpLabel - OpLoopMerge %33 %34 None - OpBranch %35 - %35 = OpLabel - %36 = OpLoad %int %i - %38 = OpSLessThan %bool %36 %int_1 - OpSelectionMerge %40 None - OpBranchConditional %38 %41 %42 - %41 = OpLabel - OpBranch %40 - %42 = OpLabel - OpBranch %33 - %40 = OpLabel - %43 = OpCompositeExtract %float %26 0 - %44 = OpCompositeConstruct %v3float %43 %43 %43 - %45 = OpCompositeExtract %float %44 0 - %47 = OpFOrdLessThan %bool %45 %float_0 - OpSelectionMerge %48 None - OpBranchConditional %47 %48 %49 - %49 = OpLabel - %50 = OpCompositeExtract %float %44 1 - %51 = OpFOrdLessThan %bool %50 %float_0 - OpBranch %48 - %48 = OpLabel - %52 = OpPhi %bool %47 %40 %51 %49 - OpSelectionMerge %53 None - OpBranchConditional %52 %53 %54 - %54 = OpLabel - %55 = OpCompositeExtract %float %44 0 - %57 = OpFOrdGreaterThan %bool %55 %float_1 - OpBranch %53 - %53 = OpLabel - %58 = OpPhi %bool %52 %48 %57 %54 - OpSelectionMerge %59 None - OpBranchConditional %58 %59 %60 - %60 = OpLabel - %61 = OpCompositeExtract %float %44 1 - %62 = OpFOrdGreaterThan %bool %61 %float_1 - OpBranch %59 - %59 = OpLabel - %63 = OpPhi %bool %58 %53 %62 %60 - OpSelectionMerge %64 None - OpBranchConditional %63 %65 %64 - %65 = OpLabel - %66 = OpLoad %int %i - %67 = OpIAdd %int %66 %int_1 - OpStore %i %67 - OpBranch %34 - %64 = OpLabel - %69 = OpLoad %11 %Sampler - %70 = OpLoad %14 %depthTexture - %71 = OpSampledImage %23 %70 %69 - %72 = OpVectorShuffle %v2float %44 %44 0 1 - %68 = OpImageSampleImplicitLod %v4float %71 %72 - %73 = OpCompositeExtract %float %68 0 - %74 = OpLoad %int %i - %75 = OpIAdd %int %74 %int_1 - OpStore %i %75 + OpStore %i %28 + OpBranch %31 + %31 = OpLabel + OpLoopMerge %32 %33 None OpBranch %34 %34 = OpLabel + %35 = OpLoad %int %i + %37 = OpSLessThan %bool %35 %int_1 + OpSelectionMerge %39 None + OpBranchConditional %37 %40 %41 + %40 = OpLabel + OpBranch %39 + %41 = OpLabel OpBranch %32 + %39 = OpLabel + %42 = OpCompositeExtract %float %26 0 + %43 = OpCompositeConstruct %v3float %42 %42 %42 + %44 = OpCompositeExtract %float %43 0 + %46 = OpFOrdLessThan %bool %44 %45 + OpSelectionMerge %47 None + OpBranchConditional %46 %47 %48 + %48 = OpLabel + %49 = OpCompositeExtract %float %43 1 + %50 = OpFOrdLessThan %bool %49 %45 + OpBranch %47 + %47 = OpLabel + %51 = OpPhi %bool %46 %39 %50 %48 + OpSelectionMerge %52 None + OpBranchConditional %51 %52 %53 + %53 = OpLabel + %54 = OpCompositeExtract %float %43 0 + %56 = OpFOrdGreaterThan %bool %54 %float_1 + OpBranch %52 + %52 = OpLabel + %57 = OpPhi %bool %51 %47 %56 %53 + OpSelectionMerge %58 None + OpBranchConditional %57 %58 %59 + %59 = OpLabel + %60 = OpCompositeExtract %float %43 1 + %61 = OpFOrdGreaterThan %bool %60 %float_1 + OpBranch %58 + %58 = OpLabel + %62 = OpPhi %bool %57 %52 %61 %59 + OpSelectionMerge %63 None + OpBranchConditional %62 %64 %63 + %64 = OpLabel + %65 = OpLoad %int %i + %66 = OpIAdd %int %65 %int_1 + OpStore %i %66 + OpBranch %33 + %63 = OpLabel + %68 = OpLoad %11 %Sampler + %69 = OpLoad %14 %depthTexture + %70 = OpSampledImage %23 %69 %68 + %71 = OpVectorShuffle %v2float %43 %43 0 1 + %67 = OpImageSampleImplicitLod %v4float %70 %71 + %72 = OpCompositeExtract %float %67 0 + %73 = OpLoad %int %i + %74 = OpIAdd %int %73 %int_1 + OpStore %i %74 + OpBranch %33 %33 = OpLabel - OpReturnValue %76 + OpBranch %31 + %32 = OpLabel + OpReturnValue %75 OpFunctionEnd - %main = OpFunction %void None %77 - %80 = OpLabel - %82 = OpLoad %v2float %vUV_1 - %81 = OpFunctionCall %v4float %main_inner %82 - OpStore %value %81 + %main = OpFunction %void None %76 + %79 = OpLabel + %81 = OpLoad %v2float %vUV_1 + %80 = OpFunctionCall %v4float %main_inner %81 + OpStore %value %80 OpReturn OpFunctionEnd diff --git a/test/tint/bug/fxc/indexed_assign_to_array_in_struct/1206.wgsl.expected.spvasm b/test/tint/bug/fxc/indexed_assign_to_array_in_struct/1206.wgsl.expected.spvasm index 68c8ccd8a1..7a4afd73a8 100644 --- a/test/tint/bug/fxc/indexed_assign_to_array_in_struct/1206.wgsl.expected.spvasm +++ b/test/tint/bug/fxc/indexed_assign_to_array_in_struct/1206.wgsl.expected.spvasm @@ -54,7 +54,7 @@ %15 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %21 = OpConstantNull %int %_ptr_StorageBuffer_Particle = OpTypePointer StorageBuffer %Particle %_ptr_Function_Particle = OpTypePointer Function %Particle %27 = OpConstantNull %Particle @@ -63,7 +63,7 @@ %main = OpFunction %void None %15 %18 = OpLabel %particle = OpVariable %_ptr_Function_Particle Function %27 - %23 = OpAccessChain %_ptr_StorageBuffer_Particle %particles %uint_0 %int_0 + %23 = OpAccessChain %_ptr_StorageBuffer_Particle %particles %uint_0 %21 %24 = OpLoad %Particle %23 OpStore %particle %24 %29 = OpAccessChain %_ptr_Uniform_uint %sim %uint_0 diff --git a/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_x.wgsl.expected.spvasm b/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_x.wgsl.expected.spvasm index c2b242a8ee..808ef9122f 100644 --- a/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_x.wgsl.expected.spvasm +++ b/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_x.wgsl.expected.spvasm @@ -33,7 +33,7 @@ %uint_0 = OpConstant %uint 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %20 = OpConstantNull %int %_ptr_Function_float = OpTypePointer Function %float %float_1 = OpConstant %float 1 %main = OpFunction %void None %5 @@ -41,7 +41,7 @@ %m1 = OpVariable %_ptr_Function_mat2v4float Function %14 %17 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 %18 = OpLoad %uint %17 - %22 = OpAccessChain %_ptr_Function_float %m1 %18 %int_0 + %22 = OpAccessChain %_ptr_Function_float %m1 %18 %20 OpStore %22 %float_1 OpReturn OpFunctionEnd diff --git a/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_y.wgsl.expected.spvasm b/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_y.wgsl.expected.spvasm index 3f68ce15e1..9f46f7d0a7 100644 --- a/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_y.wgsl.expected.spvasm +++ b/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_y.wgsl.expected.spvasm @@ -32,7 +32,7 @@ %void = OpTypeVoid %11 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %16 = OpConstantNull %int %uint_1 = OpConstant %uint 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Private_float = OpTypePointer Private %float @@ -41,7 +41,7 @@ %14 = OpLabel %19 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 %20 = OpLoad %uint %19 - %22 = OpAccessChain %_ptr_Private_float %m1 %int_0 %20 + %22 = OpAccessChain %_ptr_Private_float %m1 %16 %20 OpStore %22 %float_1 OpReturn OpFunctionEnd diff --git a/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_x.wgsl.expected.spvasm b/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_x.wgsl.expected.spvasm index b2bb365694..7b3fc5cd69 100644 --- a/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_x.wgsl.expected.spvasm +++ b/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_x.wgsl.expected.spvasm @@ -34,14 +34,14 @@ %uint_0 = OpConstant %uint 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %20 = OpConstantNull %int %_ptr_Private_float = OpTypePointer Private %float %float_1 = OpConstant %float 1 %main = OpFunction %void None %11 %14 = OpLabel %17 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 %18 = OpLoad %uint %17 - %22 = OpAccessChain %_ptr_Private_float %m1 %18 %int_0 + %22 = OpAccessChain %_ptr_Private_float %m1 %18 %20 OpStore %22 %float_1 OpReturn OpFunctionEnd diff --git a/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_y.wgsl.expected.spvasm b/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_y.wgsl.expected.spvasm index 3f68ce15e1..9f46f7d0a7 100644 --- a/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_y.wgsl.expected.spvasm +++ b/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_y.wgsl.expected.spvasm @@ -32,7 +32,7 @@ %void = OpTypeVoid %11 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %16 = OpConstantNull %int %uint_1 = OpConstant %uint 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Private_float = OpTypePointer Private %float @@ -41,7 +41,7 @@ %14 = OpLabel %19 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 %20 = OpLoad %uint %19 - %22 = OpAccessChain %_ptr_Private_float %m1 %int_0 %20 + %22 = OpAccessChain %_ptr_Private_float %m1 %16 %20 OpStore %22 %float_1 OpReturn OpFunctionEnd diff --git a/test/tint/bug/fxc/vector_assignment_in_loop/loop_call_with_loop.wgsl.expected.spvasm b/test/tint/bug/fxc/vector_assignment_in_loop/loop_call_with_loop.wgsl.expected.spvasm index 212a926008..647e2c72a0 100644 --- a/test/tint/bug/fxc/vector_assignment_in_loop/loop_call_with_loop.wgsl.expected.spvasm +++ b/test/tint/bug/fxc/vector_assignment_in_loop/loop_call_with_loop.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 72 +; Bound: 71 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -37,9 +37,8 @@ %v2b = OpVariable %_ptr_Private_v2bool Private %20 %void = OpTypeVoid %21 = OpTypeFunction %void - %int_0 = OpConstant %int 0 + %25 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %28 = OpConstantNull %int %int_2 = OpConstant %int 2 %_ptr_Private_float = OpTypePointer Private %float %float_1 = OpConstant %float 1 @@ -51,66 +50,66 @@ %true = OpConstantTrue %bool %foo = OpFunction %void None %21 %24 = OpLabel - %i = OpVariable %_ptr_Function_int Function %28 - OpStore %i %int_0 - OpBranch %29 - %29 = OpLabel - OpLoopMerge %30 %31 None - OpBranch %32 - %32 = OpLabel - %34 = OpLoad %int %i - %36 = OpSLessThan %bool %34 %int_2 - %33 = OpLogicalNot %bool %36 - OpSelectionMerge %37 None - OpBranchConditional %33 %38 %37 - %38 = OpLabel - OpBranch %30 - %37 = OpLabel - %39 = OpLoad %int %i - %41 = OpAccessChain %_ptr_Private_float %v2f %39 - OpStore %41 %float_1 - %43 = OpLoad %int %i - %45 = OpAccessChain %_ptr_Private_int %v3i %43 - OpStore %45 %int_1 - %47 = OpLoad %int %i - %49 = OpAccessChain %_ptr_Private_uint %v4u %47 - OpStore %49 %uint_1 - %51 = OpLoad %int %i - %53 = OpAccessChain %_ptr_Private_bool %v2b %51 - OpStore %53 %true + %i = OpVariable %_ptr_Function_int Function %25 + OpStore %i %25 + OpBranch %28 + %28 = OpLabel + OpLoopMerge %29 %30 None OpBranch %31 %31 = OpLabel - %55 = OpLoad %int %i - %56 = OpIAdd %int %55 %int_1 - OpStore %i %56 + %33 = OpLoad %int %i + %35 = OpSLessThan %bool %33 %int_2 + %32 = OpLogicalNot %bool %35 + OpSelectionMerge %36 None + OpBranchConditional %32 %37 %36 + %37 = OpLabel OpBranch %29 + %36 = OpLabel + %38 = OpLoad %int %i + %40 = OpAccessChain %_ptr_Private_float %v2f %38 + OpStore %40 %float_1 + %42 = OpLoad %int %i + %44 = OpAccessChain %_ptr_Private_int %v3i %42 + OpStore %44 %int_1 + %46 = OpLoad %int %i + %48 = OpAccessChain %_ptr_Private_uint %v4u %46 + OpStore %48 %uint_1 + %50 = OpLoad %int %i + %52 = OpAccessChain %_ptr_Private_bool %v2b %50 + OpStore %52 %true + OpBranch %30 %30 = OpLabel + %54 = OpLoad %int %i + %55 = OpIAdd %int %54 %int_1 + OpStore %i %55 + OpBranch %28 + %29 = OpLabel OpReturn OpFunctionEnd %main = OpFunction %void None %21 - %58 = OpLabel - %i_0 = OpVariable %_ptr_Function_int Function %28 - OpStore %i_0 %int_0 - OpBranch %60 - %60 = OpLabel - OpLoopMerge %61 %62 None - OpBranch %63 - %63 = OpLabel - %65 = OpLoad %int %i_0 - %66 = OpSLessThan %bool %65 %int_2 - %64 = OpLogicalNot %bool %66 - OpSelectionMerge %67 None - OpBranchConditional %64 %68 %67 - %68 = OpLabel - OpBranch %61 - %67 = OpLabel - %69 = OpFunctionCall %void %foo + %57 = OpLabel + %i_0 = OpVariable %_ptr_Function_int Function %25 + OpStore %i_0 %25 + OpBranch %59 + %59 = OpLabel + OpLoopMerge %60 %61 None OpBranch %62 %62 = OpLabel - %70 = OpLoad %int %i_0 - %71 = OpIAdd %int %70 %int_1 - OpStore %i_0 %71 + %64 = OpLoad %int %i_0 + %65 = OpSLessThan %bool %64 %int_2 + %63 = OpLogicalNot %bool %65 + OpSelectionMerge %66 None + OpBranchConditional %63 %67 %66 + %67 = OpLabel OpBranch %60 + %66 = OpLabel + %68 = OpFunctionCall %void %foo + OpBranch %61 %61 = OpLabel + %69 = OpLoad %int %i_0 + %70 = OpIAdd %int %69 %int_1 + OpStore %i_0 %70 + OpBranch %59 + %60 = OpLabel OpReturn OpFunctionEnd diff --git a/test/tint/bug/fxc/vector_assignment_in_loop/loop_call_with_no_loop.wgsl.expected.spvasm b/test/tint/bug/fxc/vector_assignment_in_loop/loop_call_with_no_loop.wgsl.expected.spvasm index d0b731b01a..f2cdc97c9f 100644 --- a/test/tint/bug/fxc/vector_assignment_in_loop/loop_call_with_no_loop.wgsl.expected.spvasm +++ b/test/tint/bug/fxc/vector_assignment_in_loop/loop_call_with_no_loop.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 61 +; Bound: 60 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -37,9 +37,8 @@ %v2b = OpVariable %_ptr_Private_v2bool Private %20 %void = OpTypeVoid %21 = OpTypeFunction %void - %int_0 = OpConstant %int 0 + %25 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %28 = OpConstantNull %int %_ptr_Private_float = OpTypePointer Private %float %float_1 = OpConstant %float 1 %_ptr_Private_int = OpTypePointer Private %int @@ -51,46 +50,46 @@ %int_2 = OpConstant %int 2 %foo = OpFunction %void None %21 %24 = OpLabel - %i = OpVariable %_ptr_Function_int Function %28 - OpStore %i %int_0 - %29 = OpLoad %int %i - %31 = OpAccessChain %_ptr_Private_float %v2f %29 - OpStore %31 %float_1 - %33 = OpLoad %int %i - %35 = OpAccessChain %_ptr_Private_int %v3i %33 - OpStore %35 %int_1 - %37 = OpLoad %int %i - %39 = OpAccessChain %_ptr_Private_uint %v4u %37 - OpStore %39 %uint_1 - %41 = OpLoad %int %i - %43 = OpAccessChain %_ptr_Private_bool %v2b %41 - OpStore %43 %true + %i = OpVariable %_ptr_Function_int Function %25 + OpStore %i %25 + %28 = OpLoad %int %i + %30 = OpAccessChain %_ptr_Private_float %v2f %28 + OpStore %30 %float_1 + %32 = OpLoad %int %i + %34 = OpAccessChain %_ptr_Private_int %v3i %32 + OpStore %34 %int_1 + %36 = OpLoad %int %i + %38 = OpAccessChain %_ptr_Private_uint %v4u %36 + OpStore %38 %uint_1 + %40 = OpLoad %int %i + %42 = OpAccessChain %_ptr_Private_bool %v2b %40 + OpStore %42 %true OpReturn OpFunctionEnd %main = OpFunction %void None %21 - %46 = OpLabel - %i_0 = OpVariable %_ptr_Function_int Function %28 - OpStore %i_0 %int_0 - OpBranch %48 - %48 = OpLabel - OpLoopMerge %49 %50 None - OpBranch %51 - %51 = OpLabel - %53 = OpLoad %int %i_0 - %55 = OpSLessThan %bool %53 %int_2 - %52 = OpLogicalNot %bool %55 - OpSelectionMerge %56 None - OpBranchConditional %52 %57 %56 - %57 = OpLabel - OpBranch %49 - %56 = OpLabel - %58 = OpFunctionCall %void %foo + %45 = OpLabel + %i_0 = OpVariable %_ptr_Function_int Function %25 + OpStore %i_0 %25 + OpBranch %47 + %47 = OpLabel + OpLoopMerge %48 %49 None OpBranch %50 %50 = OpLabel - %59 = OpLoad %int %i_0 - %60 = OpIAdd %int %59 %int_1 - OpStore %i_0 %60 + %52 = OpLoad %int %i_0 + %54 = OpSLessThan %bool %52 %int_2 + %51 = OpLogicalNot %bool %54 + OpSelectionMerge %55 None + OpBranchConditional %51 %56 %55 + %56 = OpLabel OpBranch %48 + %55 = OpLabel + %57 = OpFunctionCall %void %foo + OpBranch %49 %49 = OpLabel + %58 = OpLoad %int %i_0 + %59 = OpIAdd %int %58 %int_1 + OpStore %i_0 %59 + OpBranch %47 + %48 = OpLabel OpReturn OpFunctionEnd diff --git a/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_all.wgsl.expected.spvasm b/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_all.wgsl.expected.spvasm index 5a80cc6b72..f49873071d 100644 --- a/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_all.wgsl.expected.spvasm +++ b/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_all.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 104 +; Bound: 103 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -63,9 +63,8 @@ %v4bool = OpTypeVector %bool 4 %_ptr_Function_v4bool = OpTypePointer Function %v4bool %56 = OpConstantNull %v4bool - %int_0 = OpConstant %int 0 + %57 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %60 = OpConstantNull %int %int_2 = OpConstant %int 2 %_ptr_Function_float = OpTypePointer Function %float %float_1 = OpConstant %float 1 @@ -88,63 +87,63 @@ %v2b = OpVariable %_ptr_Function_v2bool Function %48 %v3b = OpVariable %_ptr_Function_v3bool Function %52 %v4b = OpVariable %_ptr_Function_v4bool Function %56 - %i = OpVariable %_ptr_Function_int Function %60 - OpStore %i %int_0 - OpBranch %61 - %61 = OpLabel - OpLoopMerge %62 %63 None - OpBranch %64 - %64 = OpLabel - %66 = OpLoad %int %i - %68 = OpSLessThan %bool %66 %int_2 - %65 = OpLogicalNot %bool %68 - OpSelectionMerge %69 None - OpBranchConditional %65 %70 %69 - %70 = OpLabel - OpBranch %62 - %69 = OpLabel - %71 = OpLoad %int %i - %73 = OpAccessChain %_ptr_Function_float %v2f %71 - OpStore %73 %float_1 - %75 = OpLoad %int %i - %76 = OpAccessChain %_ptr_Function_float %v3f %75 - OpStore %76 %float_1 - %77 = OpLoad %int %i - %78 = OpAccessChain %_ptr_Function_float %v4f %77 - OpStore %78 %float_1 - %79 = OpLoad %int %i - %80 = OpAccessChain %_ptr_Function_int %v2i %79 - OpStore %80 %int_1 - %82 = OpLoad %int %i - %83 = OpAccessChain %_ptr_Function_int %v3i %82 - OpStore %83 %int_1 - %84 = OpLoad %int %i - %85 = OpAccessChain %_ptr_Function_int %v4i %84 - OpStore %85 %int_1 - %86 = OpLoad %int %i - %88 = OpAccessChain %_ptr_Function_uint %v2u %86 - OpStore %88 %uint_1 - %90 = OpLoad %int %i - %91 = OpAccessChain %_ptr_Function_uint %v3u %90 - OpStore %91 %uint_1 - %92 = OpLoad %int %i - %93 = OpAccessChain %_ptr_Function_uint %v4u %92 - OpStore %93 %uint_1 - %94 = OpLoad %int %i - %96 = OpAccessChain %_ptr_Function_bool %v2b %94 - OpStore %96 %true - %98 = OpLoad %int %i - %99 = OpAccessChain %_ptr_Function_bool %v3b %98 - OpStore %99 %true - %100 = OpLoad %int %i - %101 = OpAccessChain %_ptr_Function_bool %v4b %100 - OpStore %101 %true + %i = OpVariable %_ptr_Function_int Function %57 + OpStore %i %57 + OpBranch %60 + %60 = OpLabel + OpLoopMerge %61 %62 None OpBranch %63 %63 = OpLabel - %102 = OpLoad %int %i - %103 = OpIAdd %int %102 %int_1 - OpStore %i %103 + %65 = OpLoad %int %i + %67 = OpSLessThan %bool %65 %int_2 + %64 = OpLogicalNot %bool %67 + OpSelectionMerge %68 None + OpBranchConditional %64 %69 %68 + %69 = OpLabel OpBranch %61 + %68 = OpLabel + %70 = OpLoad %int %i + %72 = OpAccessChain %_ptr_Function_float %v2f %70 + OpStore %72 %float_1 + %74 = OpLoad %int %i + %75 = OpAccessChain %_ptr_Function_float %v3f %74 + OpStore %75 %float_1 + %76 = OpLoad %int %i + %77 = OpAccessChain %_ptr_Function_float %v4f %76 + OpStore %77 %float_1 + %78 = OpLoad %int %i + %79 = OpAccessChain %_ptr_Function_int %v2i %78 + OpStore %79 %int_1 + %81 = OpLoad %int %i + %82 = OpAccessChain %_ptr_Function_int %v3i %81 + OpStore %82 %int_1 + %83 = OpLoad %int %i + %84 = OpAccessChain %_ptr_Function_int %v4i %83 + OpStore %84 %int_1 + %85 = OpLoad %int %i + %87 = OpAccessChain %_ptr_Function_uint %v2u %85 + OpStore %87 %uint_1 + %89 = OpLoad %int %i + %90 = OpAccessChain %_ptr_Function_uint %v3u %89 + OpStore %90 %uint_1 + %91 = OpLoad %int %i + %92 = OpAccessChain %_ptr_Function_uint %v4u %91 + OpStore %92 %uint_1 + %93 = OpLoad %int %i + %95 = OpAccessChain %_ptr_Function_bool %v2b %93 + OpStore %95 %true + %97 = OpLoad %int %i + %98 = OpAccessChain %_ptr_Function_bool %v3b %97 + OpStore %98 %true + %99 = OpLoad %int %i + %100 = OpAccessChain %_ptr_Function_bool %v4b %99 + OpStore %100 %true + OpBranch %62 %62 = OpLabel + %101 = OpLoad %int %i + %102 = OpIAdd %int %101 %int_1 + OpStore %i %102 + OpBranch %60 + %61 = OpLabel OpReturn OpFunctionEnd diff --git a/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_repeated.wgsl.expected.spvasm b/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_repeated.wgsl.expected.spvasm index ee5714c43e..828eea3786 100644 --- a/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_repeated.wgsl.expected.spvasm +++ b/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_repeated.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 68 +; Bound: 67 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -35,9 +35,8 @@ %v2bool = OpTypeVector %bool 2 %_ptr_Function_v2bool = OpTypePointer Function %v2bool %27 = OpConstantNull %v2bool - %int_0 = OpConstant %int 0 + %29 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %32 = OpConstantNull %int %int_2 = OpConstant %int 2 %_ptr_Function_float = OpTypePointer Function %float %float_1 = OpConstant %float 1 @@ -56,51 +55,51 @@ %v4u_2 = OpVariable %_ptr_Function_v4uint Function %21 %v2b = OpVariable %_ptr_Function_v2bool Function %27 %v2b_2 = OpVariable %_ptr_Function_v2bool Function %27 - %i = OpVariable %_ptr_Function_int Function %32 - OpStore %i %int_0 - OpBranch %33 - %33 = OpLabel - OpLoopMerge %34 %35 None - OpBranch %36 - %36 = OpLabel - %38 = OpLoad %int %i - %40 = OpSLessThan %bool %38 %int_2 - %37 = OpLogicalNot %bool %40 - OpSelectionMerge %41 None - OpBranchConditional %37 %42 %41 - %42 = OpLabel - OpBranch %34 - %41 = OpLabel - %43 = OpLoad %int %i - %45 = OpAccessChain %_ptr_Function_float %v2f %43 - OpStore %45 %float_1 - %47 = OpLoad %int %i - %48 = OpAccessChain %_ptr_Function_int %v3i %47 - OpStore %48 %int_1 - %50 = OpLoad %int %i - %52 = OpAccessChain %_ptr_Function_uint %v4u %50 - OpStore %52 %uint_1 - %54 = OpLoad %int %i - %56 = OpAccessChain %_ptr_Function_bool %v2b %54 - OpStore %56 %true - %58 = OpLoad %int %i - %59 = OpAccessChain %_ptr_Function_float %v2f_2 %58 - OpStore %59 %float_1 - %60 = OpLoad %int %i - %61 = OpAccessChain %_ptr_Function_int %v3i_2 %60 - OpStore %61 %int_1 - %62 = OpLoad %int %i - %63 = OpAccessChain %_ptr_Function_uint %v4u_2 %62 - OpStore %63 %uint_1 - %64 = OpLoad %int %i - %65 = OpAccessChain %_ptr_Function_bool %v2b_2 %64 - OpStore %65 %true + %i = OpVariable %_ptr_Function_int Function %29 + OpStore %i %29 + OpBranch %32 + %32 = OpLabel + OpLoopMerge %33 %34 None OpBranch %35 %35 = OpLabel - %66 = OpLoad %int %i - %67 = OpIAdd %int %66 %int_1 - OpStore %i %67 + %37 = OpLoad %int %i + %39 = OpSLessThan %bool %37 %int_2 + %36 = OpLogicalNot %bool %39 + OpSelectionMerge %40 None + OpBranchConditional %36 %41 %40 + %41 = OpLabel OpBranch %33 + %40 = OpLabel + %42 = OpLoad %int %i + %44 = OpAccessChain %_ptr_Function_float %v2f %42 + OpStore %44 %float_1 + %46 = OpLoad %int %i + %47 = OpAccessChain %_ptr_Function_int %v3i %46 + OpStore %47 %int_1 + %49 = OpLoad %int %i + %51 = OpAccessChain %_ptr_Function_uint %v4u %49 + OpStore %51 %uint_1 + %53 = OpLoad %int %i + %55 = OpAccessChain %_ptr_Function_bool %v2b %53 + OpStore %55 %true + %57 = OpLoad %int %i + %58 = OpAccessChain %_ptr_Function_float %v2f_2 %57 + OpStore %58 %float_1 + %59 = OpLoad %int %i + %60 = OpAccessChain %_ptr_Function_int %v3i_2 %59 + OpStore %60 %int_1 + %61 = OpLoad %int %i + %62 = OpAccessChain %_ptr_Function_uint %v4u_2 %61 + OpStore %62 %uint_1 + %63 = OpLoad %int %i + %64 = OpAccessChain %_ptr_Function_bool %v2b_2 %63 + OpStore %64 %true + OpBranch %34 %34 = OpLabel + %65 = OpLoad %int %i + %66 = OpIAdd %int %65 %int_1 + OpStore %i %66 + OpBranch %32 + %33 = OpLabel OpReturn OpFunctionEnd diff --git a/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_some.wgsl.expected.spvasm b/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_some.wgsl.expected.spvasm index d2938bbe2c..200f46f245 100644 --- a/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_some.wgsl.expected.spvasm +++ b/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_some.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 105 +; Bound: 104 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -64,9 +64,8 @@ %v4bool = OpTypeVector %bool 4 %_ptr_Function_v4bool = OpTypePointer Function %v4bool %56 = OpConstantNull %v4bool - %int_0 = OpConstant %int 0 + %57 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %60 = OpConstantNull %int %int_2 = OpConstant %int 2 %_ptr_Function_float = OpTypePointer Function %float %float_1 = OpConstant %float 1 @@ -89,65 +88,65 @@ %v2b = OpVariable %_ptr_Function_v2bool Function %48 %v3b = OpVariable %_ptr_Function_v3bool Function %52 %v4b = OpVariable %_ptr_Function_v4bool Function %56 - %i = OpVariable %_ptr_Function_int Function %60 - %i_0 = OpVariable %_ptr_Function_int Function %60 - OpStore %i %int_0 - OpBranch %61 - %61 = OpLabel - OpLoopMerge %62 %63 None - OpBranch %64 - %64 = OpLabel - %66 = OpLoad %int %i - %68 = OpSLessThan %bool %66 %int_2 - %65 = OpLogicalNot %bool %68 - OpSelectionMerge %69 None - OpBranchConditional %65 %70 %69 - %70 = OpLabel - OpBranch %62 - %69 = OpLabel - %71 = OpLoad %int %i - %73 = OpAccessChain %_ptr_Function_float %v2f %71 - OpStore %73 %float_1 - %75 = OpLoad %int %i - %76 = OpAccessChain %_ptr_Function_int %v2i %75 - OpStore %76 %int_1 - %78 = OpLoad %int %i - %80 = OpAccessChain %_ptr_Function_uint %v2u %78 - OpStore %80 %uint_1 - %82 = OpLoad %int %i - %84 = OpAccessChain %_ptr_Function_bool %v2b %82 - OpStore %84 %true + %i = OpVariable %_ptr_Function_int Function %57 + %i_0 = OpVariable %_ptr_Function_int Function %57 + OpStore %i %57 + OpBranch %60 + %60 = OpLabel + OpLoopMerge %61 %62 None OpBranch %63 %63 = OpLabel - %86 = OpLoad %int %i - %87 = OpIAdd %int %86 %int_1 - OpStore %i %87 + %65 = OpLoad %int %i + %67 = OpSLessThan %bool %65 %int_2 + %64 = OpLogicalNot %bool %67 + OpSelectionMerge %68 None + OpBranchConditional %64 %69 %68 + %69 = OpLabel OpBranch %61 + %68 = OpLabel + %70 = OpLoad %int %i + %72 = OpAccessChain %_ptr_Function_float %v2f %70 + OpStore %72 %float_1 + %74 = OpLoad %int %i + %75 = OpAccessChain %_ptr_Function_int %v2i %74 + OpStore %75 %int_1 + %77 = OpLoad %int %i + %79 = OpAccessChain %_ptr_Function_uint %v2u %77 + OpStore %79 %uint_1 + %81 = OpLoad %int %i + %83 = OpAccessChain %_ptr_Function_bool %v2b %81 + OpStore %83 %true + OpBranch %62 %62 = OpLabel - OpStore %i_0 %int_0 - %89 = OpLoad %int %i_0 - %90 = OpAccessChain %_ptr_Function_float %v3f %89 - OpStore %90 %float_1 - %91 = OpLoad %int %i_0 - %92 = OpAccessChain %_ptr_Function_float %v4f %91 - OpStore %92 %float_1 - %93 = OpLoad %int %i_0 - %94 = OpAccessChain %_ptr_Function_int %v3i %93 - OpStore %94 %int_1 - %95 = OpLoad %int %i_0 - %96 = OpAccessChain %_ptr_Function_int %v4i %95 - OpStore %96 %int_1 - %97 = OpLoad %int %i_0 - %98 = OpAccessChain %_ptr_Function_uint %v3u %97 - OpStore %98 %uint_1 - %99 = OpLoad %int %i_0 - %100 = OpAccessChain %_ptr_Function_uint %v4u %99 - OpStore %100 %uint_1 - %101 = OpLoad %int %i_0 - %102 = OpAccessChain %_ptr_Function_bool %v3b %101 - OpStore %102 %true - %103 = OpLoad %int %i_0 - %104 = OpAccessChain %_ptr_Function_bool %v4b %103 - OpStore %104 %true + %85 = OpLoad %int %i + %86 = OpIAdd %int %85 %int_1 + OpStore %i %86 + OpBranch %60 + %61 = OpLabel + OpStore %i_0 %57 + %88 = OpLoad %int %i_0 + %89 = OpAccessChain %_ptr_Function_float %v3f %88 + OpStore %89 %float_1 + %90 = OpLoad %int %i_0 + %91 = OpAccessChain %_ptr_Function_float %v4f %90 + OpStore %91 %float_1 + %92 = OpLoad %int %i_0 + %93 = OpAccessChain %_ptr_Function_int %v3i %92 + OpStore %93 %int_1 + %94 = OpLoad %int %i_0 + %95 = OpAccessChain %_ptr_Function_int %v4i %94 + OpStore %95 %int_1 + %96 = OpLoad %int %i_0 + %97 = OpAccessChain %_ptr_Function_uint %v3u %96 + OpStore %97 %uint_1 + %98 = OpLoad %int %i_0 + %99 = OpAccessChain %_ptr_Function_uint %v4u %98 + OpStore %99 %uint_1 + %100 = OpLoad %int %i_0 + %101 = OpAccessChain %_ptr_Function_bool %v3b %100 + OpStore %101 %true + %102 = OpLoad %int %i_0 + %103 = OpAccessChain %_ptr_Function_bool %v4b %102 + OpStore %103 %true OpReturn OpFunctionEnd diff --git a/test/tint/bug/fxc/vector_assignment_in_loop/no_loop.wgsl.expected.spvasm b/test/tint/bug/fxc/vector_assignment_in_loop/no_loop.wgsl.expected.spvasm index fc900eeeab..bc18539e7f 100644 --- a/test/tint/bug/fxc/vector_assignment_in_loop/no_loop.wgsl.expected.spvasm +++ b/test/tint/bug/fxc/vector_assignment_in_loop/no_loop.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 92 +; Bound: 91 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -63,9 +63,8 @@ %v4bool = OpTypeVector %bool 4 %_ptr_Function_v4bool = OpTypePointer Function %v4bool %56 = OpConstantNull %v4bool - %int_0 = OpConstant %int 0 + %57 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %60 = OpConstantNull %int %_ptr_Function_float = OpTypePointer Function %float %float_1 = OpConstant %float 1 %int_1 = OpConstant %int 1 @@ -87,43 +86,43 @@ %v2b = OpVariable %_ptr_Function_v2bool Function %48 %v3b = OpVariable %_ptr_Function_v3bool Function %52 %v4b = OpVariable %_ptr_Function_v4bool Function %56 - %i = OpVariable %_ptr_Function_int Function %60 - OpStore %i %int_0 - %61 = OpLoad %int %i - %63 = OpAccessChain %_ptr_Function_float %v2f %61 - OpStore %63 %float_1 - %65 = OpLoad %int %i - %66 = OpAccessChain %_ptr_Function_float %v3f %65 - OpStore %66 %float_1 - %67 = OpLoad %int %i - %68 = OpAccessChain %_ptr_Function_float %v4f %67 - OpStore %68 %float_1 - %69 = OpLoad %int %i - %70 = OpAccessChain %_ptr_Function_int %v2i %69 - OpStore %70 %int_1 - %72 = OpLoad %int %i - %73 = OpAccessChain %_ptr_Function_int %v3i %72 - OpStore %73 %int_1 - %74 = OpLoad %int %i - %75 = OpAccessChain %_ptr_Function_int %v4i %74 - OpStore %75 %int_1 - %76 = OpLoad %int %i - %78 = OpAccessChain %_ptr_Function_uint %v2u %76 - OpStore %78 %uint_1 - %80 = OpLoad %int %i - %81 = OpAccessChain %_ptr_Function_uint %v3u %80 - OpStore %81 %uint_1 - %82 = OpLoad %int %i - %83 = OpAccessChain %_ptr_Function_uint %v4u %82 - OpStore %83 %uint_1 - %84 = OpLoad %int %i - %86 = OpAccessChain %_ptr_Function_bool %v2b %84 - OpStore %86 %true - %88 = OpLoad %int %i - %89 = OpAccessChain %_ptr_Function_bool %v3b %88 - OpStore %89 %true - %90 = OpLoad %int %i - %91 = OpAccessChain %_ptr_Function_bool %v4b %90 - OpStore %91 %true + %i = OpVariable %_ptr_Function_int Function %57 + OpStore %i %57 + %60 = OpLoad %int %i + %62 = OpAccessChain %_ptr_Function_float %v2f %60 + OpStore %62 %float_1 + %64 = OpLoad %int %i + %65 = OpAccessChain %_ptr_Function_float %v3f %64 + OpStore %65 %float_1 + %66 = OpLoad %int %i + %67 = OpAccessChain %_ptr_Function_float %v4f %66 + OpStore %67 %float_1 + %68 = OpLoad %int %i + %69 = OpAccessChain %_ptr_Function_int %v2i %68 + OpStore %69 %int_1 + %71 = OpLoad %int %i + %72 = OpAccessChain %_ptr_Function_int %v3i %71 + OpStore %72 %int_1 + %73 = OpLoad %int %i + %74 = OpAccessChain %_ptr_Function_int %v4i %73 + OpStore %74 %int_1 + %75 = OpLoad %int %i + %77 = OpAccessChain %_ptr_Function_uint %v2u %75 + OpStore %77 %uint_1 + %79 = OpLoad %int %i + %80 = OpAccessChain %_ptr_Function_uint %v3u %79 + OpStore %80 %uint_1 + %81 = OpLoad %int %i + %82 = OpAccessChain %_ptr_Function_uint %v4u %81 + OpStore %82 %uint_1 + %83 = OpLoad %int %i + %85 = OpAccessChain %_ptr_Function_bool %v2b %83 + OpStore %85 %true + %87 = OpLoad %int %i + %88 = OpAccessChain %_ptr_Function_bool %v3b %87 + OpStore %88 %true + %89 = OpLoad %int %i + %90 = OpAccessChain %_ptr_Function_bool %v4b %89 + OpStore %90 %true OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/1046.wgsl.expected.spvasm b/test/tint/bug/tint/1046.wgsl.expected.spvasm index bcf15dc40e..781d830f47 100644 --- a/test/tint/bug/tint/1046.wgsl.expected.spvasm +++ b/test/tint/bug/tint/1046.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 107 +; Bound: 108 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -112,7 +112,7 @@ %_ptr_Function_v4float = OpTypePointer Function %v4float %uint_3 = OpConstant %uint 3 %_ptr_Uniform_uint = OpTypePointer Uniform %uint - %uint_0 = OpConstant %uint 0 + %41 = OpConstantNull %uint %bool = OpTypeBool %uint_1 = OpConstant %uint 1 %_ptr_Function_float = OpTypePointer Function %float @@ -125,17 +125,18 @@ %82 = OpTypeFunction %FragmentOutput %FragmentInput %_ptr_Function_FragmentOutput = OpTypePointer Function %FragmentOutput %89 = OpConstantNull %FragmentOutput + %uint_0 = OpConstant %uint 0 %float_0 = OpConstant %float 0 - %92 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_1 + %93 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_1 %void = OpTypeVoid - %95 = OpTypeFunction %void + %96 = OpTypeFunction %void %getColor = OpFunction %v4float None %30 %fragment = OpFunctionParameter %FragmentInput %34 = OpLabel %color = OpVariable %_ptr_Function_v4float Function %13 %39 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_3 %40 = OpLoad %uint %39 - %42 = OpIEqual %bool %40 %uint_0 + %42 = OpIEqual %bool %40 %41 OpSelectionMerge %44 None OpBranchConditional %42 %45 %46 %45 = OpLabel @@ -193,21 +194,21 @@ %fragment_0 = OpFunctionParameter %FragmentInput %86 = OpLabel %output = OpVariable %_ptr_Function_FragmentOutput Function %89 - %90 = OpAccessChain %_ptr_Function_v4float %output %uint_0 - OpStore %90 %92 - %94 = OpLoad %FragmentOutput %output - OpReturnValue %94 + %91 = OpAccessChain %_ptr_Function_v4float %output %uint_0 + OpStore %91 %93 + %95 = OpLoad %FragmentOutput %output + OpReturnValue %95 OpFunctionEnd - %main = OpFunction %void None %95 - %98 = OpLabel - %100 = OpLoad %v4float %position_1 - %101 = OpLoad %v4float %view_position_1 - %102 = OpLoad %v4float %normal_1 - %103 = OpLoad %v2float %uv_1 - %104 = OpLoad %v4float %color_1 - %105 = OpCompositeConstruct %FragmentInput %100 %101 %102 %103 %104 - %99 = OpFunctionCall %FragmentOutput %main_inner %105 - %106 = OpCompositeExtract %v4float %99 0 - OpStore %color_2 %106 + %main = OpFunction %void None %96 + %99 = OpLabel + %101 = OpLoad %v4float %position_1 + %102 = OpLoad %v4float %view_position_1 + %103 = OpLoad %v4float %normal_1 + %104 = OpLoad %v2float %uv_1 + %105 = OpLoad %v4float %color_1 + %106 = OpCompositeConstruct %FragmentInput %101 %102 %103 %104 %105 + %100 = OpFunctionCall %FragmentOutput %main_inner %106 + %107 = OpCompositeExtract %v4float %100 0 + OpStore %color_2 %107 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/1064.wgsl.expected.spvasm b/test/tint/bug/tint/1064.wgsl.expected.spvasm index 5ebd236719..139a11061d 100644 --- a/test/tint/bug/tint/1064.wgsl.expected.spvasm +++ b/test/tint/bug/tint/1064.wgsl.expected.spvasm @@ -11,7 +11,7 @@ %void = OpTypeVoid %1 = OpTypeFunction %void %bool = OpTypeBool - %false = OpConstantFalse %bool + %10 = OpConstantNull %bool %true = OpConstantTrue %bool %main = OpFunction %void None %1 %4 = OpLabel @@ -21,7 +21,7 @@ OpBranch %8 %8 = OpLabel OpSelectionMerge %11 None - OpBranchConditional %false %12 %13 + OpBranchConditional %10 %12 %13 %12 = OpLabel OpBranch %11 %13 = OpLabel diff --git a/test/tint/bug/tint/1076.wgsl.expected.spvasm b/test/tint/bug/tint/1076.wgsl.expected.spvasm index 33e81b1a8f..133728b3ac 100644 --- a/test/tint/bug/tint/1076.wgsl.expected.spvasm +++ b/test/tint/bug/tint/1076.wgsl.expected.spvasm @@ -44,12 +44,12 @@ %mask_2 = OpVariable %_ptr_Output__arr_uint_uint_1 Output %15 %FragIn = OpTypeStruct %float %uint %16 = OpTypeFunction %FragIn %FragIn %float - %uint_0 = OpConstant %uint 0 + %23 = OpConstantNull %uint %bool = OpTypeBool %void = OpTypeVoid %29 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %36 = OpConstantNull %int %_ptr_Input_uint = OpTypePointer Input %uint %_ptr_Output_uint = OpTypePointer Output %uint %main_inner = OpFunction %FragIn None %16 @@ -57,7 +57,7 @@ %b = OpFunctionParameter %float %21 = OpLabel %22 = OpCompositeExtract %uint %in 1 - %24 = OpIEqual %bool %22 %uint_0 + %24 = OpIEqual %bool %22 %23 OpSelectionMerge %26 None OpBranchConditional %24 %27 %26 %27 = OpLabel @@ -69,14 +69,14 @@ %main = OpFunction %void None %29 %32 = OpLabel %34 = OpLoad %float %a_1 - %38 = OpAccessChain %_ptr_Input_uint %mask_1 %int_0 + %38 = OpAccessChain %_ptr_Input_uint %mask_1 %36 %39 = OpLoad %uint %38 %40 = OpCompositeConstruct %FragIn %34 %39 %41 = OpLoad %float %b_1 %33 = OpFunctionCall %FragIn %main_inner %40 %41 %42 = OpCompositeExtract %float %33 0 OpStore %a_2 %42 - %44 = OpAccessChain %_ptr_Output_uint %mask_2 %int_0 + %44 = OpAccessChain %_ptr_Output_uint %mask_2 %36 %45 = OpCompositeExtract %uint %33 1 OpStore %44 %45 OpReturn diff --git a/test/tint/bug/tint/1081.wgsl.expected.spvasm b/test/tint/bug/tint/1081.wgsl.expected.spvasm index 53e025c9eb..bee21ae78c 100644 --- a/test/tint/bug/tint/1081.wgsl.expected.spvasm +++ b/test/tint/bug/tint/1081.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 51 +; Bound: 50 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -28,9 +28,9 @@ %7 = OpConstantNull %int %value = OpVariable %_ptr_Output_int Output %7 %bool = OpTypeBool - %false = OpConstantFalse %bool + %9 = OpConstantNull %bool %_ptr_Private_bool = OpTypePointer Private %bool -%tint_discard = OpVariable %_ptr_Private_bool Private %false +%tint_discard = OpVariable %_ptr_Private_bool Private %9 %12 = OpTypeFunction %int %int %int_10 = OpConstant %int 10 %true = OpConstantTrue %bool @@ -38,7 +38,6 @@ %21 = OpTypeFunction %void %25 = OpTypeFunction %int %v3int %_ptr_Function_int = OpTypePointer Function %int - %int_0 = OpConstant %int 0 %f = OpFunction %int None %12 %x = OpFunctionParameter %int %15 = OpLabel @@ -75,23 +74,23 @@ %41 = OpFunctionCall %void %tint_discard_func OpReturnValue %7 %39 = OpLabel - %43 = OpIEqual %bool %36 %int_0 - OpSelectionMerge %44 None - OpBranchConditional %43 %45 %44 - %45 = OpLabel - OpBranch %33 + %42 = OpIEqual %bool %36 %7 + OpSelectionMerge %43 None + OpBranchConditional %42 %44 %43 %44 = OpLabel + OpBranch %33 + %43 = OpLabel OpBranch %34 %34 = OpLabel OpBranch %32 %33 = OpLabel - %46 = OpLoad %int %y - OpReturnValue %46 + %45 = OpLoad %int %y + OpReturnValue %45 OpFunctionEnd %main = OpFunction %void None %21 - %48 = OpLabel - %50 = OpLoad %v3int %x_1 - %49 = OpFunctionCall %int %main_inner %50 - OpStore %value %49 + %47 = OpLabel + %49 = OpLoad %v3int %x_1 + %48 = OpFunctionCall %int %main_inner %49 + OpStore %value %48 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/1083.wgsl.expected.spvasm b/test/tint/bug/tint/1083.wgsl.expected.spvasm index 47589eb15f..fa188bd8fe 100644 --- a/test/tint/bug/tint/1083.wgsl.expected.spvasm +++ b/test/tint/bug/tint/1083.wgsl.expected.spvasm @@ -12,9 +12,9 @@ %1 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 - %int_0 = OpConstant %int 0 + %7 = OpConstantNull %int %f = OpFunction %void None %1 %4 = OpLabel - %8 = OpSDiv %int %int_1 %int_0 + %8 = OpSDiv %int %int_1 %7 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/1086.wgsl.expected.spvasm b/test/tint/bug/tint/1086.wgsl.expected.spvasm index c2a13c6005..2c300ad818 100644 --- a/test/tint/bug/tint/1086.wgsl.expected.spvasm +++ b/test/tint/bug/tint/1086.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 20 +; Bound: 19 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -18,21 +18,20 @@ %v = OpVariable %_ptr_Private_float Private %4 %void = OpTypeVoid %5 = OpTypeFunction %void %_ptr_Private_float - %float_0 = OpConstant %float 0 - %12 = OpTypeFunction %void + %11 = OpTypeFunction %void %x = OpFunction %void None %5 %p = OpFunctionParameter %_ptr_Private_float %9 = OpLabel - OpStore %p %float_0 + OpStore %p %4 OpReturn OpFunctionEnd - %g = OpFunction %void None %12 - %14 = OpLabel - %15 = OpFunctionCall %void %x %v + %g = OpFunction %void None %11 + %13 = OpLabel + %14 = OpFunctionCall %void %x %v OpReturn OpFunctionEnd - %f = OpFunction %void None %12 - %18 = OpLabel - %19 = OpFunctionCall %void %g + %f = OpFunction %void None %11 + %17 = OpLabel + %18 = OpFunctionCall %void %g OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/1088.spvasm.expected.spvasm b/test/tint/bug/tint/1088.spvasm.expected.spvasm index f157cd1751..6b84892307 100644 --- a/test/tint/bug/tint/1088.spvasm.expected.spvasm +++ b/test/tint/bug/tint/1088.spvasm.expected.spvasm @@ -106,7 +106,7 @@ %_ptr_Function_float = OpTypePointer Function %float %uint_3 = OpConstant %uint 3 %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %63 = OpConstantNull %int %_ptr_Uniform_float = OpTypePointer Uniform %float %uint_1 = OpConstant %uint 1 %_ptr_Private_float = OpTypePointer Private %float @@ -133,7 +133,7 @@ OpStore %p %56 %59 = OpAccessChain %_ptr_Function_float %p %uint_0 %60 = OpLoad %float %59 - %65 = OpAccessChain %_ptr_Uniform_float %x_14 %uint_3 %int_0 %uint_0 + %65 = OpAccessChain %_ptr_Uniform_float %x_14 %uint_3 %63 %uint_0 %66 = OpLoad %float %65 %69 = OpAccessChain %_ptr_Private_float %position %uint_1 %70 = OpLoad %float %69 diff --git a/test/tint/bug/tint/1113.wgsl.expected.spvasm b/test/tint/bug/tint/1113.wgsl.expected.spvasm index 124f9cf86d..8a91127124 100644 --- a/test/tint/bug/tint/1113.wgsl.expected.spvasm +++ b/test/tint/bug/tint/1113.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 403 +; Bound: 402 ; Schema: 0 OpCapability Shader %65 = OpExtInstImport "GLSL.std.450" @@ -217,12 +217,11 @@ %void = OpTypeVoid %175 = OpTypeFunction %void %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint - %int_0 = OpConstant %int 0 + %188 = OpConstantNull %int %_ptr_StorageBuffer_uint_0 = OpTypePointer StorageBuffer %uint %_ptr_StorageBuffer_int = OpTypePointer StorageBuffer %int %_ptr_Function_int = OpTypePointer Function %int - %204 = OpConstantNull %int - %205 = OpTypeFunction %void %v3uint + %204 = OpTypeFunction %void %v3uint %bool = OpTypeBool %float_3 = OpConstant %float 3 %uint_8 = OpConstant %uint 8 @@ -356,7 +355,7 @@ %157 = OpLabel %position_0 = OpVariable %_ptr_Function_v3float Function %50 %159 = OpIMul %uint %uint_3 %vertexIndex - %160 = OpIAdd %uint %159 %uint_0 + %160 = OpIAdd %uint %159 %141 %162 = OpAccessChain %_ptr_StorageBuffer_float %positions %uint_0 %160 %163 = OpLoad %float %162 %164 = OpIMul %uint %uint_3 %vertexIndex @@ -379,30 +378,30 @@ %b53 = OpVariable %_ptr_Function_uint Function %141 %rwg = OpVariable %_ptr_Function_uint Function %141 %rb5 = OpVariable %_ptr_Function_float Function %75 - %g55 = OpVariable %_ptr_Function_int Function %204 + %g55 = OpVariable %_ptr_Function_int Function %188 %179 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 %180 = OpLoad %uint %179 OpStore %g42 %180 %183 = OpAccessChain %_ptr_StorageBuffer_uint %dbg %uint_5 %184 = OpLoad %uint %183 OpStore %kj6 %184 - %190 = OpAccessChain %_ptr_StorageBuffer_uint_0 %counters %uint_0 %int_0 + %190 = OpAccessChain %_ptr_StorageBuffer_uint_0 %counters %uint_0 %188 %186 = OpAtomicLoad %uint %190 %uint_1 %uint_0 OpStore %b53 %186 - %192 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %int_0 + %192 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %188 %193 = OpLoad %uint %192 OpStore %rwg %193 - %195 = OpAccessChain %_ptr_StorageBuffer_float %positions %uint_0 %int_0 + %195 = OpAccessChain %_ptr_StorageBuffer_float %positions %uint_0 %188 %196 = OpLoad %float %195 OpStore %rb5 %196 - %201 = OpAccessChain %_ptr_StorageBuffer_int %LUT %uint_0 %int_0 + %201 = OpAccessChain %_ptr_StorageBuffer_int %LUT %uint_0 %188 %198 = OpAtomicLoad %int %201 %uint_1 %uint_0 OpStore %g55 %198 OpReturn OpFunctionEnd -%main_count_inner = OpFunction %void None %205 +%main_count_inner = OpFunction %void None %204 %GlobalInvocationID = OpFunctionParameter %v3uint - %208 = OpLabel + %207 = OpLabel %triangleIndex = OpVariable %_ptr_Function_uint Function %141 %i0 = OpVariable %_ptr_Function_uint Function %141 %i1 = OpVariable %_ptr_Function_uint Function %141 @@ -410,160 +409,160 @@ %p0 = OpVariable %_ptr_Function_v3float Function %50 %p1 = OpVariable %_ptr_Function_v3float Function %50 %p2 = OpVariable %_ptr_Function_v3float Function %50 - %253 = OpVariable %_ptr_Function_v3float Function %50 + %252 = OpVariable %_ptr_Function_v3float Function %50 %center = OpVariable %_ptr_Function_v3float Function %50 %voxelPos_0 = OpVariable %_ptr_Function_v3float Function %50 %voxelIndex = OpVariable %_ptr_Function_uint Function %141 %acefg = OpVariable %_ptr_Function_uint Function %141 - %209 = OpCompositeExtract %uint %GlobalInvocationID 0 - OpStore %triangleIndex %209 - %211 = OpLoad %uint %triangleIndex - %212 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 - %213 = OpLoad %uint %212 - %214 = OpUGreaterThanEqual %bool %211 %213 - OpSelectionMerge %216 None - OpBranchConditional %214 %217 %216 - %217 = OpLabel - OpReturn + %208 = OpCompositeExtract %uint %GlobalInvocationID 0 + OpStore %triangleIndex %208 + %210 = OpLoad %uint %triangleIndex + %211 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 + %212 = OpLoad %uint %211 + %213 = OpUGreaterThanEqual %bool %210 %212 + OpSelectionMerge %215 None + OpBranchConditional %213 %216 %215 %216 = OpLabel - %218 = OpFunctionCall %void %doIgnore - %219 = OpLoad %uint %triangleIndex - %220 = OpIMul %uint %uint_3 %219 - %221 = OpIAdd %uint %220 %uint_0 - %222 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %221 - %223 = OpLoad %uint %222 - OpStore %i0 %223 - %225 = OpLoad %uint %triangleIndex - %226 = OpIMul %uint %uint_3 %225 - %227 = OpIAdd %uint %226 %uint_1 - %228 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %227 - %229 = OpLoad %uint %228 - OpStore %i1 %229 - %231 = OpLoad %uint %triangleIndex - %232 = OpIMul %uint %uint_3 %231 - %233 = OpIAdd %uint %232 %uint_2 - %234 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %233 - %235 = OpLoad %uint %234 - OpStore %i2 %235 - %238 = OpLoad %uint %i0 - %237 = OpFunctionCall %v3float %loadPosition %238 - OpStore %p0 %237 - %241 = OpLoad %uint %i1 - %240 = OpFunctionCall %v3float %loadPosition %241 - OpStore %p1 %240 - %244 = OpLoad %uint %i2 - %243 = OpFunctionCall %v3float %loadPosition %244 - OpStore %p2 %243 - %246 = OpLoad %v3float %p0 - %247 = OpLoad %v3float %p1 - %248 = OpFAdd %v3float %246 %247 - %249 = OpLoad %v3float %p2 - %250 = OpFAdd %v3float %248 %249 - %254 = OpCompositeConstruct %v3float %float_3 %float_3 %float_3 - %252 = OpFDiv %v3float %250 %254 - OpStore %center %252 - %257 = OpLoad %v3float %center - %256 = OpFunctionCall %v3float %toVoxelPos %257 - OpStore %voxelPos_0 %256 - %260 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 - %261 = OpLoad %uint %260 - %262 = OpLoad %v3float %voxelPos_0 - %259 = OpFunctionCall %uint %toIndex1D %261 %262 - OpStore %voxelIndex %259 - %266 = OpLoad %uint %voxelIndex - %267 = OpAccessChain %_ptr_StorageBuffer_uint_0 %counters %uint_0 %266 - %264 = OpAtomicIAdd %uint %267 %uint_1 %uint_0 %uint_1 - OpStore %acefg %264 - %269 = OpLoad %uint %triangleIndex - %270 = OpIEqual %bool %269 %uint_0 - OpSelectionMerge %271 None - OpBranchConditional %270 %272 %271 - %272 = OpLabel - %273 = OpAccessChain %_ptr_StorageBuffer_uint %dbg %uint_4 - %274 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 - %275 = OpLoad %uint %274 - OpStore %273 %275 - %277 = OpAccessChain %_ptr_StorageBuffer_float %dbg %uint_8 - %278 = OpAccessChain %_ptr_Function_float %center %uint_0 - %279 = OpLoad %float %278 - OpStore %277 %279 - %281 = OpAccessChain %_ptr_StorageBuffer_float %dbg %uint_9 - %282 = OpAccessChain %_ptr_Function_float %center %uint_1 - %283 = OpLoad %float %282 - OpStore %281 %283 - %285 = OpAccessChain %_ptr_StorageBuffer_float %dbg %uint_10 - %286 = OpAccessChain %_ptr_Function_float %center %uint_2 - %287 = OpLoad %float %286 - OpStore %285 %287 - OpBranch %271 + OpReturn + %215 = OpLabel + %217 = OpFunctionCall %void %doIgnore + %218 = OpLoad %uint %triangleIndex + %219 = OpIMul %uint %uint_3 %218 + %220 = OpIAdd %uint %219 %141 + %221 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %220 + %222 = OpLoad %uint %221 + OpStore %i0 %222 + %224 = OpLoad %uint %triangleIndex + %225 = OpIMul %uint %uint_3 %224 + %226 = OpIAdd %uint %225 %uint_1 + %227 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %226 + %228 = OpLoad %uint %227 + OpStore %i1 %228 + %230 = OpLoad %uint %triangleIndex + %231 = OpIMul %uint %uint_3 %230 + %232 = OpIAdd %uint %231 %uint_2 + %233 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %232 + %234 = OpLoad %uint %233 + OpStore %i2 %234 + %237 = OpLoad %uint %i0 + %236 = OpFunctionCall %v3float %loadPosition %237 + OpStore %p0 %236 + %240 = OpLoad %uint %i1 + %239 = OpFunctionCall %v3float %loadPosition %240 + OpStore %p1 %239 + %243 = OpLoad %uint %i2 + %242 = OpFunctionCall %v3float %loadPosition %243 + OpStore %p2 %242 + %245 = OpLoad %v3float %p0 + %246 = OpLoad %v3float %p1 + %247 = OpFAdd %v3float %245 %246 + %248 = OpLoad %v3float %p2 + %249 = OpFAdd %v3float %247 %248 + %253 = OpCompositeConstruct %v3float %float_3 %float_3 %float_3 + %251 = OpFDiv %v3float %249 %253 + OpStore %center %251 + %256 = OpLoad %v3float %center + %255 = OpFunctionCall %v3float %toVoxelPos %256 + OpStore %voxelPos_0 %255 + %259 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 + %260 = OpLoad %uint %259 + %261 = OpLoad %v3float %voxelPos_0 + %258 = OpFunctionCall %uint %toIndex1D %260 %261 + OpStore %voxelIndex %258 + %265 = OpLoad %uint %voxelIndex + %266 = OpAccessChain %_ptr_StorageBuffer_uint_0 %counters %uint_0 %265 + %263 = OpAtomicIAdd %uint %266 %uint_1 %uint_0 %uint_1 + OpStore %acefg %263 + %268 = OpLoad %uint %triangleIndex + %269 = OpIEqual %bool %268 %141 + OpSelectionMerge %270 None + OpBranchConditional %269 %271 %270 %271 = OpLabel + %272 = OpAccessChain %_ptr_StorageBuffer_uint %dbg %uint_4 + %273 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 + %274 = OpLoad %uint %273 + OpStore %272 %274 + %276 = OpAccessChain %_ptr_StorageBuffer_float %dbg %uint_8 + %277 = OpAccessChain %_ptr_Function_float %center %uint_0 + %278 = OpLoad %float %277 + OpStore %276 %278 + %280 = OpAccessChain %_ptr_StorageBuffer_float %dbg %uint_9 + %281 = OpAccessChain %_ptr_Function_float %center %uint_1 + %282 = OpLoad %float %281 + OpStore %280 %282 + %284 = OpAccessChain %_ptr_StorageBuffer_float %dbg %uint_10 + %285 = OpAccessChain %_ptr_Function_float %center %uint_2 + %286 = OpLoad %float %285 + OpStore %284 %286 + OpBranch %270 + %270 = OpLabel OpReturn OpFunctionEnd %main_count = OpFunction %void None %175 - %289 = OpLabel - %291 = OpLoad %v3uint %GlobalInvocationID_1 - %290 = OpFunctionCall %void %main_count_inner %291 + %288 = OpLabel + %290 = OpLoad %v3uint %GlobalInvocationID_1 + %289 = OpFunctionCall %void %main_count_inner %290 OpReturn OpFunctionEnd -%main_create_lut_inner = OpFunction %void None %205 +%main_create_lut_inner = OpFunction %void None %204 %GlobalInvocationID_0 = OpFunctionParameter %v3uint - %294 = OpLabel + %293 = OpLabel %voxelIndex_0 = OpVariable %_ptr_Function_uint Function %141 %maxVoxels = OpVariable %_ptr_Function_uint Function %141 %numTriangles = OpVariable %_ptr_Function_uint Function %141 - %offset = OpVariable %_ptr_Function_int Function %204 - %295 = OpCompositeExtract %uint %GlobalInvocationID_0 0 - OpStore %voxelIndex_0 %295 - %297 = OpFunctionCall %void %doIgnore - %298 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 - %299 = OpLoad %uint %298 - %300 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 - %301 = OpLoad %uint %300 - %302 = OpIMul %uint %299 %301 - %303 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 - %304 = OpLoad %uint %303 - %305 = OpIMul %uint %302 %304 - OpStore %maxVoxels %305 - %307 = OpLoad %uint %voxelIndex_0 - %308 = OpLoad %uint %maxVoxels - %309 = OpUGreaterThanEqual %bool %307 %308 - OpSelectionMerge %310 None - OpBranchConditional %309 %311 %310 - %311 = OpLabel - OpReturn + %offset = OpVariable %_ptr_Function_int Function %188 + %294 = OpCompositeExtract %uint %GlobalInvocationID_0 0 + OpStore %voxelIndex_0 %294 + %296 = OpFunctionCall %void %doIgnore + %297 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 + %298 = OpLoad %uint %297 + %299 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 + %300 = OpLoad %uint %299 + %301 = OpIMul %uint %298 %300 + %302 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 + %303 = OpLoad %uint %302 + %304 = OpIMul %uint %301 %303 + OpStore %maxVoxels %304 + %306 = OpLoad %uint %voxelIndex_0 + %307 = OpLoad %uint %maxVoxels + %308 = OpUGreaterThanEqual %bool %306 %307 + OpSelectionMerge %309 None + OpBranchConditional %308 %310 %309 %310 = OpLabel - %314 = OpLoad %uint %voxelIndex_0 - %315 = OpAccessChain %_ptr_StorageBuffer_uint_0 %counters %uint_0 %314 - %312 = OpAtomicLoad %uint %315 %uint_1 %uint_0 - OpStore %numTriangles %312 + OpReturn + %309 = OpLabel + %313 = OpLoad %uint %voxelIndex_0 + %314 = OpAccessChain %_ptr_StorageBuffer_uint_0 %counters %uint_0 %313 + %311 = OpAtomicLoad %uint %314 %uint_1 %uint_0 + OpStore %numTriangles %311 OpStore %offset %int_n1 - %319 = OpLoad %uint %numTriangles - %320 = OpUGreaterThan %bool %319 %uint_0 - OpSelectionMerge %321 None - OpBranchConditional %320 %322 %321 - %322 = OpLabel - %325 = OpAccessChain %_ptr_StorageBuffer_uint_0 %dbg %uint_0 - %326 = OpLoad %uint %numTriangles - %323 = OpAtomicIAdd %uint %325 %uint_1 %uint_0 %326 - %327 = OpBitcast %int %323 - OpStore %offset %327 - OpBranch %321 + %318 = OpLoad %uint %numTriangles + %319 = OpUGreaterThan %bool %318 %141 + OpSelectionMerge %320 None + OpBranchConditional %319 %321 %320 %321 = OpLabel - %330 = OpLoad %uint %voxelIndex_0 - %331 = OpAccessChain %_ptr_StorageBuffer_int %LUT %uint_0 %330 - %332 = OpLoad %int %offset - OpAtomicStore %331 %uint_1 %uint_0 %332 + %324 = OpAccessChain %_ptr_StorageBuffer_uint_0 %dbg %uint_0 + %325 = OpLoad %uint %numTriangles + %322 = OpAtomicIAdd %uint %324 %uint_1 %uint_0 %325 + %326 = OpBitcast %int %322 + OpStore %offset %326 + OpBranch %320 + %320 = OpLabel + %329 = OpLoad %uint %voxelIndex_0 + %330 = OpAccessChain %_ptr_StorageBuffer_int %LUT %uint_0 %329 + %331 = OpLoad %int %offset + OpAtomicStore %330 %uint_1 %uint_0 %331 OpReturn OpFunctionEnd %main_create_lut = OpFunction %void None %175 - %334 = OpLabel - %336 = OpLoad %v3uint %GlobalInvocationID_2 - %335 = OpFunctionCall %void %main_create_lut_inner %336 + %333 = OpLabel + %335 = OpLoad %v3uint %GlobalInvocationID_2 + %334 = OpFunctionCall %void %main_create_lut_inner %335 OpReturn OpFunctionEnd -%main_sort_triangles_inner = OpFunction %void None %205 +%main_sort_triangles_inner = OpFunction %void None %204 %GlobalInvocationID_4 = OpFunctionParameter %v3uint - %339 = OpLabel + %338 = OpLabel %triangleIndex_0 = OpVariable %_ptr_Function_uint Function %141 %i0_0 = OpVariable %_ptr_Function_uint Function %141 %i1_0 = OpVariable %_ptr_Function_uint Function %141 @@ -571,75 +570,75 @@ %p0_0 = OpVariable %_ptr_Function_v3float Function %50 %p1_0 = OpVariable %_ptr_Function_v3float Function %50 %p2_0 = OpVariable %_ptr_Function_v3float Function %50 - %382 = OpVariable %_ptr_Function_v3float Function %50 + %381 = OpVariable %_ptr_Function_v3float Function %50 %center_0 = OpVariable %_ptr_Function_v3float Function %50 %voxelPos_1 = OpVariable %_ptr_Function_v3float Function %50 %voxelIndex_1 = OpVariable %_ptr_Function_uint Function %141 -%triangleOffset = OpVariable %_ptr_Function_int Function %204 - %340 = OpCompositeExtract %uint %GlobalInvocationID_4 0 - OpStore %triangleIndex_0 %340 - %342 = OpFunctionCall %void %doIgnore - %343 = OpLoad %uint %triangleIndex_0 - %344 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 - %345 = OpLoad %uint %344 - %346 = OpUGreaterThanEqual %bool %343 %345 - OpSelectionMerge %347 None - OpBranchConditional %346 %348 %347 - %348 = OpLabel - OpReturn +%triangleOffset = OpVariable %_ptr_Function_int Function %188 + %339 = OpCompositeExtract %uint %GlobalInvocationID_4 0 + OpStore %triangleIndex_0 %339 + %341 = OpFunctionCall %void %doIgnore + %342 = OpLoad %uint %triangleIndex_0 + %343 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 + %344 = OpLoad %uint %343 + %345 = OpUGreaterThanEqual %bool %342 %344 + OpSelectionMerge %346 None + OpBranchConditional %345 %347 %346 %347 = OpLabel - %349 = OpLoad %uint %triangleIndex_0 - %350 = OpIMul %uint %uint_3 %349 - %351 = OpIAdd %uint %350 %uint_0 - %352 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %351 - %353 = OpLoad %uint %352 - OpStore %i0_0 %353 - %355 = OpLoad %uint %triangleIndex_0 - %356 = OpIMul %uint %uint_3 %355 - %357 = OpIAdd %uint %356 %uint_1 - %358 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %357 - %359 = OpLoad %uint %358 - OpStore %i1_0 %359 - %361 = OpLoad %uint %triangleIndex_0 - %362 = OpIMul %uint %uint_3 %361 - %363 = OpIAdd %uint %362 %uint_2 - %364 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %363 - %365 = OpLoad %uint %364 - OpStore %i2_0 %365 - %368 = OpLoad %uint %i0_0 - %367 = OpFunctionCall %v3float %loadPosition %368 - OpStore %p0_0 %367 - %371 = OpLoad %uint %i1_0 - %370 = OpFunctionCall %v3float %loadPosition %371 - OpStore %p1_0 %370 - %374 = OpLoad %uint %i2_0 - %373 = OpFunctionCall %v3float %loadPosition %374 - OpStore %p2_0 %373 - %376 = OpLoad %v3float %p0_0 - %377 = OpLoad %v3float %p1_0 - %378 = OpFAdd %v3float %376 %377 - %379 = OpLoad %v3float %p2_0 - %380 = OpFAdd %v3float %378 %379 - %383 = OpCompositeConstruct %v3float %float_3 %float_3 %float_3 - %381 = OpFDiv %v3float %380 %383 - OpStore %center_0 %381 - %386 = OpLoad %v3float %center_0 - %385 = OpFunctionCall %v3float %toVoxelPos %386 - OpStore %voxelPos_1 %385 - %389 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 - %390 = OpLoad %uint %389 - %391 = OpLoad %v3float %voxelPos_1 - %388 = OpFunctionCall %uint %toIndex1D %390 %391 - OpStore %voxelIndex_1 %388 - %395 = OpLoad %uint %voxelIndex_1 - %396 = OpAccessChain %_ptr_StorageBuffer_int %LUT %uint_0 %395 - %393 = OpAtomicIAdd %int %396 %uint_1 %uint_0 %int_1 - OpStore %triangleOffset %393 + OpReturn + %346 = OpLabel + %348 = OpLoad %uint %triangleIndex_0 + %349 = OpIMul %uint %uint_3 %348 + %350 = OpIAdd %uint %349 %141 + %351 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %350 + %352 = OpLoad %uint %351 + OpStore %i0_0 %352 + %354 = OpLoad %uint %triangleIndex_0 + %355 = OpIMul %uint %uint_3 %354 + %356 = OpIAdd %uint %355 %uint_1 + %357 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %356 + %358 = OpLoad %uint %357 + OpStore %i1_0 %358 + %360 = OpLoad %uint %triangleIndex_0 + %361 = OpIMul %uint %uint_3 %360 + %362 = OpIAdd %uint %361 %uint_2 + %363 = OpAccessChain %_ptr_StorageBuffer_uint %indices %uint_0 %362 + %364 = OpLoad %uint %363 + OpStore %i2_0 %364 + %367 = OpLoad %uint %i0_0 + %366 = OpFunctionCall %v3float %loadPosition %367 + OpStore %p0_0 %366 + %370 = OpLoad %uint %i1_0 + %369 = OpFunctionCall %v3float %loadPosition %370 + OpStore %p1_0 %369 + %373 = OpLoad %uint %i2_0 + %372 = OpFunctionCall %v3float %loadPosition %373 + OpStore %p2_0 %372 + %375 = OpLoad %v3float %p0_0 + %376 = OpLoad %v3float %p1_0 + %377 = OpFAdd %v3float %375 %376 + %378 = OpLoad %v3float %p2_0 + %379 = OpFAdd %v3float %377 %378 + %382 = OpCompositeConstruct %v3float %float_3 %float_3 %float_3 + %380 = OpFDiv %v3float %379 %382 + OpStore %center_0 %380 + %385 = OpLoad %v3float %center_0 + %384 = OpFunctionCall %v3float %toVoxelPos %385 + OpStore %voxelPos_1 %384 + %388 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 + %389 = OpLoad %uint %388 + %390 = OpLoad %v3float %voxelPos_1 + %387 = OpFunctionCall %uint %toIndex1D %389 %390 + OpStore %voxelIndex_1 %387 + %394 = OpLoad %uint %voxelIndex_1 + %395 = OpAccessChain %_ptr_StorageBuffer_int %LUT %uint_0 %394 + %392 = OpAtomicIAdd %int %395 %uint_1 %uint_0 %int_1 + OpStore %triangleOffset %392 OpReturn OpFunctionEnd %main_sort_triangles = OpFunction %void None %175 - %400 = OpLabel - %402 = OpLoad %v3uint %GlobalInvocationID_3 - %401 = OpFunctionCall %void %main_sort_triangles_inner %402 + %399 = OpLabel + %401 = OpLoad %v3uint %GlobalInvocationID_3 + %400 = OpFunctionCall %void %main_sort_triangles_inner %401 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/1118.wgsl.expected.spvasm b/test/tint/bug/tint/1118.wgsl.expected.spvasm index 7e3d8447b4..c4595fc78f 100644 --- a/test/tint/bug/tint/1118.wgsl.expected.spvasm +++ b/test/tint/bug/tint/1118.wgsl.expected.spvasm @@ -13,10 +13,10 @@ bug/tint/1118.wgsl:46:19 note: reading from module-scope private variable 'fClip ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 198 +; Bound: 195 ; Schema: 0 OpCapability Shader - %73 = OpExtInstImport "GLSL.std.450" + %71 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %fClipDistance3_param_1 %fClipDistance4_param_1 %glFragColor_1_1 OpExecutionMode %main OriginUpperLeft @@ -112,9 +112,9 @@ bug/tint/1118.wgsl:46:19 note: reading from module-scope private variable 'fClip %_ptr_Private_v4float = OpTypePointer Private %v4float %glFragColor = OpVariable %_ptr_Private_v4float Private %8 %bool = OpTypeBool - %false = OpConstantFalse %bool + %26 = OpConstantNull %bool %_ptr_Private_bool = OpTypePointer Private %bool -%tint_discard = OpVariable %_ptr_Private_bool Private %false +%tint_discard = OpVariable %_ptr_Private_bool Private %26 %void = OpTypeVoid %29 = OpTypeFunction %void %_ptr_Function_v3float = OpTypePointer Function %v3float @@ -124,25 +124,22 @@ bug/tint/1118.wgsl:46:19 note: reading from module-scope private variable 'fClip %v2float = OpTypeVector %float 2 %_ptr_Function_v2float = OpTypePointer Function %v2float %45 = OpConstantNull %v2float - %float_0 = OpConstant %float 0 %true = OpConstantTrue %bool %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float - %71 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %float_1 = OpConstant %float 1 - %80 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 + %78 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %uint_3 = OpConstant %uint 3 %_ptr_Uniform_float = OpTypePointer Uniform %float - %96 = OpConstantComposite %v2float %float_0 %float_0 - %97 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 - %114 = OpConstantComposite %v3float %float_1 %float_1 %float_1 - %115 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_1 + %110 = OpConstantComposite %v3float %float_1 %float_1 %float_1 + %float_0 = OpConstant %float 0 + %112 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_1 %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %uint_1 = OpConstant %uint 1 %main_out = OpTypeStruct %v4float - %178 = OpTypeFunction %main_out %float %float - %189 = OpConstantNull %main_out + %175 = OpTypeFunction %main_out %float %float + %186 = OpConstantNull %main_out %main_1 = OpFunction %void None %29 %32 = OpLabel %viewDirectionW = OpVariable %_ptr_Function_v3float Function %35 @@ -162,166 +159,166 @@ bug/tint/1118.wgsl:46:19 note: reading from module-scope private variable 'fClip %finalSpecular = OpVariable %_ptr_Function_v3float Function %35 %color = OpVariable %_ptr_Function_v4float Function %8 %56 = OpLoad %float %fClipDistance3 - %58 = OpFOrdGreaterThan %bool %56 %float_0 - OpSelectionMerge %59 None - OpBranchConditional %58 %60 %59 - %60 = OpLabel - OpStore %tint_discard %true - OpReturn + %57 = OpFOrdGreaterThan %bool %56 %11 + OpSelectionMerge %58 None + OpBranchConditional %57 %59 %58 %59 = OpLabel - %62 = OpLoad %float %fClipDistance4 - %63 = OpFOrdGreaterThan %bool %62 %float_0 - OpSelectionMerge %64 None - OpBranchConditional %63 %65 %64 - %65 = OpLabel OpStore %tint_discard %true OpReturn + %58 = OpLabel + %61 = OpLoad %float %fClipDistance4 + %62 = OpFOrdGreaterThan %bool %61 %11 + OpSelectionMerge %63 None + OpBranchConditional %62 %64 %63 %64 = OpLabel - %69 = OpAccessChain %_ptr_Uniform_v4float %x_29 %uint_0 - %70 = OpLoad %v4float %69 - %74 = OpCompositeExtract %float %70 0 - %75 = OpCompositeExtract %float %70 1 - %76 = OpCompositeExtract %float %70 2 - %77 = OpCompositeConstruct %v3float %74 %75 %76 - %78 = OpFSub %v3float %77 %71 - %72 = OpExtInst %v3float %73 Normalize %78 - OpStore %viewDirectionW %72 - OpStore %baseColor %80 - %81 = OpAccessChain %_ptr_Uniform_v4float %x_49 %uint_0 - %82 = OpLoad %v4float %81 - %83 = OpCompositeExtract %float %82 0 - %84 = OpCompositeExtract %float %82 1 - %85 = OpCompositeExtract %float %82 2 - %86 = OpCompositeConstruct %v3float %83 %84 %85 - OpStore %diffuseColor %86 - %89 = OpAccessChain %_ptr_Uniform_float %x_49 %uint_0 %uint_3 - %90 = OpLoad %float %89 - OpStore %alpha %90 - %94 = OpDPdx %v3float %71 - %95 = OpDPdy %v3float %71 - %93 = OpExtInst %v3float %73 Cross %94 %95 - %92 = OpFNegate %v3float %93 - %91 = OpExtInst %v3float %73 Normalize %92 - OpStore %normalW %91 - OpStore %uvOffset %96 - %98 = OpLoad %v4float %baseColor - %99 = OpCompositeExtract %float %98 0 - %100 = OpCompositeExtract %float %98 1 - %101 = OpCompositeExtract %float %98 2 + OpStore %tint_discard %true + OpReturn + %63 = OpLabel + %68 = OpAccessChain %_ptr_Uniform_v4float %x_29 %uint_0 + %69 = OpLoad %v4float %68 + %72 = OpCompositeExtract %float %69 0 + %73 = OpCompositeExtract %float %69 1 + %74 = OpCompositeExtract %float %69 2 + %75 = OpCompositeConstruct %v3float %72 %73 %74 + %76 = OpFSub %v3float %75 %35 + %70 = OpExtInst %v3float %71 Normalize %76 + OpStore %viewDirectionW %70 + OpStore %baseColor %78 + %79 = OpAccessChain %_ptr_Uniform_v4float %x_49 %uint_0 + %80 = OpLoad %v4float %79 + %81 = OpCompositeExtract %float %80 0 + %82 = OpCompositeExtract %float %80 1 + %83 = OpCompositeExtract %float %80 2 + %84 = OpCompositeConstruct %v3float %81 %82 %83 + OpStore %diffuseColor %84 + %87 = OpAccessChain %_ptr_Uniform_float %x_49 %uint_0 %uint_3 + %88 = OpLoad %float %87 + OpStore %alpha %88 + %92 = OpDPdx %v3float %35 + %93 = OpDPdy %v3float %35 + %91 = OpExtInst %v3float %71 Cross %92 %93 + %90 = OpFNegate %v3float %91 + %89 = OpExtInst %v3float %71 Normalize %90 + OpStore %normalW %89 + OpStore %uvOffset %45 + %94 = OpLoad %v4float %baseColor + %95 = OpCompositeExtract %float %94 0 + %96 = OpCompositeExtract %float %94 1 + %97 = OpCompositeExtract %float %94 2 + %98 = OpCompositeConstruct %v3float %95 %96 %97 + %99 = OpCompositeExtract %float %8 0 + %100 = OpCompositeExtract %float %8 1 + %101 = OpCompositeExtract %float %8 2 %102 = OpCompositeConstruct %v3float %99 %100 %101 - %103 = OpCompositeExtract %float %97 0 - %104 = OpCompositeExtract %float %97 1 - %105 = OpCompositeExtract %float %97 2 - %106 = OpCompositeConstruct %v3float %103 %104 %105 - %107 = OpFMul %v3float %102 %106 - %108 = OpLoad %v4float %baseColor - %109 = OpCompositeExtract %float %107 0 - %110 = OpCompositeExtract %float %107 1 - %111 = OpCompositeExtract %float %107 2 - %112 = OpCompositeExtract %float %108 3 - %113 = OpCompositeConstruct %v4float %109 %110 %111 %112 - OpStore %baseColor %113 - OpStore %baseAmbientColor %114 - OpStore %glossiness %float_0 - OpStore %diffuseBase %71 + %103 = OpFMul %v3float %98 %102 + %104 = OpLoad %v4float %baseColor + %105 = OpCompositeExtract %float %103 0 + %106 = OpCompositeExtract %float %103 1 + %107 = OpCompositeExtract %float %103 2 + %108 = OpCompositeExtract %float %104 3 + %109 = OpCompositeConstruct %v4float %105 %106 %107 %108 + OpStore %baseColor %109 + OpStore %baseAmbientColor %110 + OpStore %glossiness %11 + OpStore %diffuseBase %35 OpStore %shadow %float_1 - OpStore %refractionColor %115 - OpStore %reflectionColor %115 - %117 = OpAccessChain %_ptr_Uniform_v3float %x_49 %uint_3 - %118 = OpLoad %v3float %117 - OpStore %emissiveColor %118 - %119 = OpLoad %v3float %diffuseBase - %120 = OpLoad %v3float %diffuseColor - %121 = OpLoad %v3float %emissiveColor - %123 = OpAccessChain %_ptr_Uniform_v3float %x_49 %uint_1 - %124 = OpLoad %v3float %123 - %125 = OpLoad %v4float %baseColor - %127 = OpFMul %v3float %119 %120 - %128 = OpFAdd %v3float %127 %121 - %129 = OpFAdd %v3float %128 %124 - %126 = OpExtInst %v3float %73 NClamp %129 %71 %114 - %130 = OpCompositeExtract %float %125 0 - %131 = OpCompositeExtract %float %125 1 - %132 = OpCompositeExtract %float %125 2 - %133 = OpCompositeConstruct %v3float %130 %131 %132 - %134 = OpFMul %v3float %126 %133 - OpStore %finalDiffuse %134 - OpStore %finalSpecular %71 - %135 = OpLoad %v3float %finalDiffuse - %136 = OpLoad %v3float %baseAmbientColor - %137 = OpLoad %v3float %finalSpecular - %138 = OpLoad %v4float %reflectionColor - %139 = OpLoad %v4float %refractionColor - %140 = OpFMul %v3float %135 %136 - %141 = OpFAdd %v3float %140 %137 - %142 = OpCompositeExtract %float %138 0 - %143 = OpCompositeExtract %float %138 1 - %144 = OpCompositeExtract %float %138 2 - %145 = OpCompositeConstruct %v3float %142 %143 %144 - %146 = OpFAdd %v3float %141 %145 - %147 = OpCompositeExtract %float %139 0 - %148 = OpCompositeExtract %float %139 1 - %149 = OpCompositeExtract %float %139 2 - %150 = OpCompositeConstruct %v3float %147 %148 %149 - %151 = OpFAdd %v3float %146 %150 - %152 = OpLoad %float %alpha - %153 = OpCompositeExtract %float %151 0 - %154 = OpCompositeExtract %float %151 1 - %155 = OpCompositeExtract %float %151 2 - %156 = OpCompositeConstruct %v4float %153 %154 %155 %152 - OpStore %color %156 - %157 = OpLoad %v4float %color - %159 = OpCompositeExtract %float %157 0 - %160 = OpCompositeExtract %float %157 1 - %161 = OpCompositeExtract %float %157 2 - %162 = OpCompositeConstruct %v3float %159 %160 %161 - %158 = OpExtInst %v3float %73 NMax %162 %71 - %163 = OpLoad %v4float %color - %164 = OpCompositeExtract %float %158 0 - %165 = OpCompositeExtract %float %158 1 - %166 = OpCompositeExtract %float %158 2 - %167 = OpCompositeExtract %float %163 3 - %168 = OpCompositeConstruct %v4float %164 %165 %166 %167 - OpStore %color %168 - %169 = OpAccessChain %_ptr_Uniform_float %x_137 %uint_0 - %170 = OpLoad %float %169 - %171 = OpAccessChain %_ptr_Function_float %color %uint_3 - %172 = OpLoad %float %171 - %173 = OpAccessChain %_ptr_Function_float %color %uint_3 - %174 = OpFMul %float %172 %170 - OpStore %173 %174 - %175 = OpLoad %v4float %color - OpStore %glFragColor %175 + OpStore %refractionColor %112 + OpStore %reflectionColor %112 + %114 = OpAccessChain %_ptr_Uniform_v3float %x_49 %uint_3 + %115 = OpLoad %v3float %114 + OpStore %emissiveColor %115 + %116 = OpLoad %v3float %diffuseBase + %117 = OpLoad %v3float %diffuseColor + %118 = OpLoad %v3float %emissiveColor + %120 = OpAccessChain %_ptr_Uniform_v3float %x_49 %uint_1 + %121 = OpLoad %v3float %120 + %122 = OpLoad %v4float %baseColor + %124 = OpFMul %v3float %116 %117 + %125 = OpFAdd %v3float %124 %118 + %126 = OpFAdd %v3float %125 %121 + %123 = OpExtInst %v3float %71 NClamp %126 %35 %110 + %127 = OpCompositeExtract %float %122 0 + %128 = OpCompositeExtract %float %122 1 + %129 = OpCompositeExtract %float %122 2 + %130 = OpCompositeConstruct %v3float %127 %128 %129 + %131 = OpFMul %v3float %123 %130 + OpStore %finalDiffuse %131 + OpStore %finalSpecular %35 + %132 = OpLoad %v3float %finalDiffuse + %133 = OpLoad %v3float %baseAmbientColor + %134 = OpLoad %v3float %finalSpecular + %135 = OpLoad %v4float %reflectionColor + %136 = OpLoad %v4float %refractionColor + %137 = OpFMul %v3float %132 %133 + %138 = OpFAdd %v3float %137 %134 + %139 = OpCompositeExtract %float %135 0 + %140 = OpCompositeExtract %float %135 1 + %141 = OpCompositeExtract %float %135 2 + %142 = OpCompositeConstruct %v3float %139 %140 %141 + %143 = OpFAdd %v3float %138 %142 + %144 = OpCompositeExtract %float %136 0 + %145 = OpCompositeExtract %float %136 1 + %146 = OpCompositeExtract %float %136 2 + %147 = OpCompositeConstruct %v3float %144 %145 %146 + %148 = OpFAdd %v3float %143 %147 + %149 = OpLoad %float %alpha + %150 = OpCompositeExtract %float %148 0 + %151 = OpCompositeExtract %float %148 1 + %152 = OpCompositeExtract %float %148 2 + %153 = OpCompositeConstruct %v4float %150 %151 %152 %149 + OpStore %color %153 + %154 = OpLoad %v4float %color + %156 = OpCompositeExtract %float %154 0 + %157 = OpCompositeExtract %float %154 1 + %158 = OpCompositeExtract %float %154 2 + %159 = OpCompositeConstruct %v3float %156 %157 %158 + %155 = OpExtInst %v3float %71 NMax %159 %35 + %160 = OpLoad %v4float %color + %161 = OpCompositeExtract %float %155 0 + %162 = OpCompositeExtract %float %155 1 + %163 = OpCompositeExtract %float %155 2 + %164 = OpCompositeExtract %float %160 3 + %165 = OpCompositeConstruct %v4float %161 %162 %163 %164 + OpStore %color %165 + %166 = OpAccessChain %_ptr_Uniform_float %x_137 %uint_0 + %167 = OpLoad %float %166 + %168 = OpAccessChain %_ptr_Function_float %color %uint_3 + %169 = OpLoad %float %168 + %170 = OpAccessChain %_ptr_Function_float %color %uint_3 + %171 = OpFMul %float %169 %167 + OpStore %170 %171 + %172 = OpLoad %v4float %color + OpStore %glFragColor %172 OpReturn OpFunctionEnd %tint_discard_func = OpFunction %void None %29 - %177 = OpLabel + %174 = OpLabel OpKill OpFunctionEnd - %main_inner = OpFunction %main_out None %178 + %main_inner = OpFunction %main_out None %175 %fClipDistance3_param = OpFunctionParameter %float %fClipDistance4_param = OpFunctionParameter %float - %183 = OpLabel + %180 = OpLabel OpStore %fClipDistance3 %fClipDistance3_param OpStore %fClipDistance4 %fClipDistance4_param - %184 = OpFunctionCall %void %main_1 - %185 = OpLoad %bool %tint_discard - OpSelectionMerge %186 None - OpBranchConditional %185 %187 %186 - %187 = OpLabel - %188 = OpFunctionCall %void %tint_discard_func - OpReturnValue %189 - %186 = OpLabel - %190 = OpLoad %v4float %glFragColor - %191 = OpCompositeConstruct %main_out %190 - OpReturnValue %191 + %181 = OpFunctionCall %void %main_1 + %182 = OpLoad %bool %tint_discard + OpSelectionMerge %183 None + OpBranchConditional %182 %184 %183 + %184 = OpLabel + %185 = OpFunctionCall %void %tint_discard_func + OpReturnValue %186 + %183 = OpLabel + %187 = OpLoad %v4float %glFragColor + %188 = OpCompositeConstruct %main_out %187 + OpReturnValue %188 OpFunctionEnd %main = OpFunction %void None %29 - %193 = OpLabel - %195 = OpLoad %float %fClipDistance3_param_1 - %196 = OpLoad %float %fClipDistance4_param_1 - %194 = OpFunctionCall %main_out %main_inner %195 %196 - %197 = OpCompositeExtract %v4float %194 0 - OpStore %glFragColor_1_1 %197 + %190 = OpLabel + %192 = OpLoad %float %fClipDistance3_param_1 + %193 = OpLoad %float %fClipDistance4_param_1 + %191 = OpFunctionCall %main_out %main_inner %192 %193 + %194 = OpCompositeExtract %v4float %191 0 + OpStore %glFragColor_1_1 %194 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/1121.wgsl.expected.spvasm b/test/tint/bug/tint/1121.wgsl.expected.spvasm index e9ee84c048..97e8eb57ed 100644 --- a/test/tint/bug/tint/1121.wgsl.expected.spvasm +++ b/test/tint/bug/tint/1121.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 417 +; Bound: 415 ; Schema: 0 OpCapability Shader %60 = OpExtInstImport "GLSL.std.450" @@ -157,31 +157,29 @@ %_ptr_Function_v4float = OpTypePointer Function %v4float %117 = OpConstantNull %v4float %uint_2 = OpConstant %uint 2 - %float_0 = OpConstant %float 0 %uint_6 = OpConstant %uint 6 %_arr_v4float_uint_6 = OpTypeArray %v4float %uint_6 %_ptr_Function__arr_v4float_uint_6 = OpTypePointer Function %_arr_v4float_uint_6 - %156 = OpConstantNull %_arr_v4float_uint_6 + %155 = OpConstantNull %_arr_v4float_uint_6 %int_4 = OpConstant %int 4 %int_5 = OpConstant %int 5 %int_16 = OpConstant %int 16 - %int_0 = OpConstant %int 0 + %166 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %170 = OpConstantNull %int %v2int = OpTypeVector %int 2 %_ptr_Function_v2int = OpTypePointer Function %v2int - %198 = OpConstantNull %v2int + %196 = OpConstantNull %v2int %float_2 = OpConstant %float 2 %v2float = OpTypeVector %float 2 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float - %209 = OpConstantComposite %v2float %float_1 %float_1 + %207 = OpConstantComposite %v2float %float_1 %float_1 %_ptr_Function_v2float = OpTypePointer Function %v2float - %213 = OpConstantNull %v2float - %216 = OpConstantComposite %v2int %int_16 %int_16 + %211 = OpConstantNull %v2float + %214 = OpConstantComposite %v2int %int_16 %int_16 %int_1 = OpConstant %int 1 %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint %_ptr_StorageBuffer_uint_0 = OpTypePointer StorageBuffer %uint - %412 = OpTypeFunction %void + %410 = OpTypeFunction %void %main_inner = OpFunction %void None %28 %GlobalInvocationID = OpFunctionParameter %v3uint %32 = OpLabel @@ -194,14 +192,14 @@ %lightRadius = OpVariable %_ptr_Function_float Function %101 %boxMin = OpVariable %_ptr_Function_v4float Function %117 %boxMax = OpVariable %_ptr_Function_v4float Function %117 -%frustumPlanes = OpVariable %_ptr_Function__arr_v4float_uint_6 Function %156 - %y = OpVariable %_ptr_Function_int Function %170 - %x = OpVariable %_ptr_Function_int Function %170 -%tilePixel0Idx = OpVariable %_ptr_Function_v2int Function %198 - %floorCoord = OpVariable %_ptr_Function_v2float Function %213 - %ceilCoord = OpVariable %_ptr_Function_v2float Function %213 -%viewFloorCoord = OpVariable %_ptr_Function_v2float Function %213 -%viewCeilCoord = OpVariable %_ptr_Function_v2float Function %213 +%frustumPlanes = OpVariable %_ptr_Function__arr_v4float_uint_6 Function %155 + %y = OpVariable %_ptr_Function_int Function %166 + %x = OpVariable %_ptr_Function_int Function %166 +%tilePixel0Idx = OpVariable %_ptr_Function_v2int Function %196 + %floorCoord = OpVariable %_ptr_Function_v2float Function %211 + %ceilCoord = OpVariable %_ptr_Function_v2float Function %211 +%viewFloorCoord = OpVariable %_ptr_Function_v2float Function %211 +%viewCeilCoord = OpVariable %_ptr_Function_v2float Function %211 %dp = OpVariable %_ptr_Function_float Function %101 %i = OpVariable %_ptr_Function_uint Function %36 %p = OpVariable %_ptr_Function_v4float Function %117 @@ -295,323 +293,323 @@ %136 = OpCompositeExtract %float %135 0 %137 = OpCompositeExtract %float %135 1 %138 = OpCompositeExtract %float %135 2 - %140 = OpCompositeConstruct %v4float %136 %137 %138 %float_0 - %141 = OpFSub %v4float %133 %140 - OpStore %boxMin %141 - %143 = OpLoad %v4float %lightPos - %144 = OpLoad %float %lightRadius - %145 = OpCompositeConstruct %v3float %144 %144 %144 - %146 = OpCompositeExtract %float %145 0 - %147 = OpCompositeExtract %float %145 1 - %148 = OpCompositeExtract %float %145 2 - %149 = OpCompositeConstruct %v4float %146 %147 %148 %float_0 - %150 = OpFAdd %v4float %143 %149 - OpStore %boxMax %150 - %158 = OpAccessChain %_ptr_Function_v4float %frustumPlanes %int_4 - %159 = OpLoad %float %viewNear - %160 = OpCompositeConstruct %v4float %float_0 %float_0 %float_n1 %159 - OpStore %158 %160 - %162 = OpAccessChain %_ptr_Function_v4float %frustumPlanes %int_5 - %164 = OpLoad %float %viewFar - %163 = OpFNegate %float %164 - %165 = OpCompositeConstruct %v4float %float_0 %float_0 %float_1 %163 - OpStore %162 %165 - OpStore %y %int_0 - OpBranch %171 - %171 = OpLabel - OpLoopMerge %172 %173 None - OpBranch %174 - %174 = OpLabel - %176 = OpLoad %int %y - %177 = OpSLessThan %bool %176 %int_2 - %175 = OpLogicalNot %bool %177 - OpSelectionMerge %178 None - OpBranchConditional %175 %179 %178 - %179 = OpLabel + %139 = OpCompositeConstruct %v4float %136 %137 %138 %101 + %140 = OpFSub %v4float %133 %139 + OpStore %boxMin %140 + %142 = OpLoad %v4float %lightPos + %143 = OpLoad %float %lightRadius + %144 = OpCompositeConstruct %v3float %143 %143 %143 + %145 = OpCompositeExtract %float %144 0 + %146 = OpCompositeExtract %float %144 1 + %147 = OpCompositeExtract %float %144 2 + %148 = OpCompositeConstruct %v4float %145 %146 %147 %101 + %149 = OpFAdd %v4float %142 %148 + OpStore %boxMax %149 + %157 = OpAccessChain %_ptr_Function_v4float %frustumPlanes %int_4 + %158 = OpLoad %float %viewNear + %159 = OpCompositeConstruct %v4float %101 %101 %float_n1 %158 + OpStore %157 %159 + %161 = OpAccessChain %_ptr_Function_v4float %frustumPlanes %int_5 + %163 = OpLoad %float %viewFar + %162 = OpFNegate %float %163 + %164 = OpCompositeConstruct %v4float %101 %101 %float_1 %162 + OpStore %161 %164 + OpStore %y %166 + OpBranch %169 + %169 = OpLabel + OpLoopMerge %170 %171 None OpBranch %172 - %178 = OpLabel - OpStore %x %int_0 - OpBranch %181 - %181 = OpLabel - OpLoopMerge %182 %183 None - OpBranch %184 - %184 = OpLabel - %186 = OpLoad %int %x - %187 = OpSLessThan %bool %186 %int_2 - %185 = OpLogicalNot %bool %187 - OpSelectionMerge %188 None - OpBranchConditional %185 %189 %188 - %189 = OpLabel + %172 = OpLabel + %174 = OpLoad %int %y + %175 = OpSLessThan %bool %174 %int_2 + %173 = OpLogicalNot %bool %175 + OpSelectionMerge %176 None + OpBranchConditional %173 %177 %176 + %177 = OpLabel + OpBranch %170 + %176 = OpLabel + OpStore %x %166 + OpBranch %179 + %179 = OpLabel + OpLoopMerge %180 %181 None OpBranch %182 - %188 = OpLabel - %191 = OpLoad %int %x + %182 = OpLabel + %184 = OpLoad %int %x + %185 = OpSLessThan %bool %184 %int_2 + %183 = OpLogicalNot %bool %185 + OpSelectionMerge %186 None + OpBranchConditional %183 %187 %186 + %187 = OpLabel + OpBranch %180 + %186 = OpLabel + %189 = OpLoad %int %x + %190 = OpIMul %int %189 %int_16 + %191 = OpLoad %int %y %192 = OpIMul %int %191 %int_16 - %193 = OpLoad %int %y - %194 = OpIMul %int %193 %int_16 - %195 = OpCompositeConstruct %v2int %192 %194 - OpStore %tilePixel0Idx %195 - %202 = OpLoad %v2int %tilePixel0Idx - %200 = OpConvertSToF %v2float %202 - %203 = OpVectorTimesScalar %v2float %200 %float_2 - %205 = OpAccessChain %_ptr_Uniform_v4float %uniforms %uint_4 - %206 = OpLoad %v4float %205 - %207 = OpVectorShuffle %v2float %206 %206 0 1 - %208 = OpFDiv %v2float %203 %207 - %210 = OpFSub %v2float %208 %209 - OpStore %floorCoord %210 - %215 = OpLoad %v2int %tilePixel0Idx - %217 = OpIAdd %v2int %215 %216 - %214 = OpConvertSToF %v2float %217 - %218 = OpVectorTimesScalar %v2float %214 %float_2 - %219 = OpAccessChain %_ptr_Uniform_v4float %uniforms %uint_4 - %220 = OpLoad %v4float %219 - %221 = OpVectorShuffle %v2float %220 %220 0 1 - %222 = OpFDiv %v2float %218 %221 - %223 = OpFSub %v2float %222 %209 - OpStore %ceilCoord %223 - %226 = OpLoad %float %viewNear - %225 = OpFNegate %float %226 - %227 = OpAccessChain %_ptr_Function_float %floorCoord %uint_0 - %228 = OpLoad %float %227 - %229 = OpFMul %float %225 %228 - %230 = OpAccessChain %_ptr_Function_float %M %int_2 %int_0 - %231 = OpLoad %float %230 - %232 = OpLoad %float %viewNear - %233 = OpFMul %float %231 %232 - %234 = OpFSub %float %229 %233 - %235 = OpAccessChain %_ptr_Function_float %M %int_0 %int_0 - %236 = OpLoad %float %235 - %237 = OpFDiv %float %234 %236 - %239 = OpLoad %float %viewNear - %238 = OpFNegate %float %239 - %240 = OpAccessChain %_ptr_Function_float %floorCoord %uint_1 - %241 = OpLoad %float %240 - %242 = OpFMul %float %238 %241 - %244 = OpAccessChain %_ptr_Function_float %M %int_2 %int_1 - %245 = OpLoad %float %244 - %246 = OpLoad %float %viewNear - %247 = OpFMul %float %245 %246 - %248 = OpFSub %float %242 %247 - %249 = OpAccessChain %_ptr_Function_float %M %int_1 %int_1 - %250 = OpLoad %float %249 - %251 = OpFDiv %float %248 %250 - %252 = OpCompositeConstruct %v2float %237 %251 - OpStore %viewFloorCoord %252 - %255 = OpLoad %float %viewNear - %254 = OpFNegate %float %255 - %256 = OpAccessChain %_ptr_Function_float %ceilCoord %uint_0 - %257 = OpLoad %float %256 - %258 = OpFMul %float %254 %257 - %259 = OpAccessChain %_ptr_Function_float %M %int_2 %int_0 - %260 = OpLoad %float %259 - %261 = OpLoad %float %viewNear - %262 = OpFMul %float %260 %261 - %263 = OpFSub %float %258 %262 - %264 = OpAccessChain %_ptr_Function_float %M %int_0 %int_0 - %265 = OpLoad %float %264 - %266 = OpFDiv %float %263 %265 - %268 = OpLoad %float %viewNear - %267 = OpFNegate %float %268 - %269 = OpAccessChain %_ptr_Function_float %ceilCoord %uint_1 - %270 = OpLoad %float %269 - %271 = OpFMul %float %267 %270 - %272 = OpAccessChain %_ptr_Function_float %M %int_2 %int_1 - %273 = OpLoad %float %272 - %274 = OpLoad %float %viewNear - %275 = OpFMul %float %273 %274 - %276 = OpFSub %float %271 %275 - %277 = OpAccessChain %_ptr_Function_float %M %int_1 %int_1 - %278 = OpLoad %float %277 - %279 = OpFDiv %float %276 %278 - %280 = OpCompositeConstruct %v2float %266 %279 - OpStore %viewCeilCoord %280 - %282 = OpAccessChain %_ptr_Function_v4float %frustumPlanes %int_0 - %284 = OpAccessChain %_ptr_Function_float %viewFloorCoord %uint_0 - %285 = OpLoad %float %284 - %283 = OpFNegate %float %285 - %286 = OpLoad %float %viewNear - %287 = OpFDiv %float %283 %286 - %288 = OpCompositeConstruct %v4float %float_1 %float_0 %287 %float_0 - OpStore %282 %288 - %289 = OpAccessChain %_ptr_Function_v4float %frustumPlanes %int_1 - %290 = OpAccessChain %_ptr_Function_float %viewCeilCoord %uint_0 - %291 = OpLoad %float %290 - %292 = OpLoad %float %viewNear - %293 = OpFDiv %float %291 %292 - %294 = OpCompositeConstruct %v4float %float_n1 %float_0 %293 %float_0 - OpStore %289 %294 - %295 = OpAccessChain %_ptr_Function_v4float %frustumPlanes %int_2 - %297 = OpAccessChain %_ptr_Function_float %viewFloorCoord %uint_1 - %298 = OpLoad %float %297 - %296 = OpFNegate %float %298 - %299 = OpLoad %float %viewNear - %300 = OpFDiv %float %296 %299 - %301 = OpCompositeConstruct %v4float %float_0 %float_1 %300 %float_0 - OpStore %295 %301 - %302 = OpAccessChain %_ptr_Function_v4float %frustumPlanes %int_3 - %303 = OpAccessChain %_ptr_Function_float %viewCeilCoord %uint_1 - %304 = OpLoad %float %303 - %305 = OpLoad %float %viewNear - %306 = OpFDiv %float %304 %305 - %307 = OpCompositeConstruct %v4float %float_0 %float_n1 %306 %float_0 - OpStore %302 %307 - OpStore %dp %float_0 - OpStore %i %uint_0 + %193 = OpCompositeConstruct %v2int %190 %192 + OpStore %tilePixel0Idx %193 + %200 = OpLoad %v2int %tilePixel0Idx + %198 = OpConvertSToF %v2float %200 + %201 = OpVectorTimesScalar %v2float %198 %float_2 + %203 = OpAccessChain %_ptr_Uniform_v4float %uniforms %uint_4 + %204 = OpLoad %v4float %203 + %205 = OpVectorShuffle %v2float %204 %204 0 1 + %206 = OpFDiv %v2float %201 %205 + %208 = OpFSub %v2float %206 %207 + OpStore %floorCoord %208 + %213 = OpLoad %v2int %tilePixel0Idx + %215 = OpIAdd %v2int %213 %214 + %212 = OpConvertSToF %v2float %215 + %216 = OpVectorTimesScalar %v2float %212 %float_2 + %217 = OpAccessChain %_ptr_Uniform_v4float %uniforms %uint_4 + %218 = OpLoad %v4float %217 + %219 = OpVectorShuffle %v2float %218 %218 0 1 + %220 = OpFDiv %v2float %216 %219 + %221 = OpFSub %v2float %220 %207 + OpStore %ceilCoord %221 + %224 = OpLoad %float %viewNear + %223 = OpFNegate %float %224 + %225 = OpAccessChain %_ptr_Function_float %floorCoord %uint_0 + %226 = OpLoad %float %225 + %227 = OpFMul %float %223 %226 + %228 = OpAccessChain %_ptr_Function_float %M %int_2 %166 + %229 = OpLoad %float %228 + %230 = OpLoad %float %viewNear + %231 = OpFMul %float %229 %230 + %232 = OpFSub %float %227 %231 + %233 = OpAccessChain %_ptr_Function_float %M %166 %166 + %234 = OpLoad %float %233 + %235 = OpFDiv %float %232 %234 + %237 = OpLoad %float %viewNear + %236 = OpFNegate %float %237 + %238 = OpAccessChain %_ptr_Function_float %floorCoord %uint_1 + %239 = OpLoad %float %238 + %240 = OpFMul %float %236 %239 + %242 = OpAccessChain %_ptr_Function_float %M %int_2 %int_1 + %243 = OpLoad %float %242 + %244 = OpLoad %float %viewNear + %245 = OpFMul %float %243 %244 + %246 = OpFSub %float %240 %245 + %247 = OpAccessChain %_ptr_Function_float %M %int_1 %int_1 + %248 = OpLoad %float %247 + %249 = OpFDiv %float %246 %248 + %250 = OpCompositeConstruct %v2float %235 %249 + OpStore %viewFloorCoord %250 + %253 = OpLoad %float %viewNear + %252 = OpFNegate %float %253 + %254 = OpAccessChain %_ptr_Function_float %ceilCoord %uint_0 + %255 = OpLoad %float %254 + %256 = OpFMul %float %252 %255 + %257 = OpAccessChain %_ptr_Function_float %M %int_2 %166 + %258 = OpLoad %float %257 + %259 = OpLoad %float %viewNear + %260 = OpFMul %float %258 %259 + %261 = OpFSub %float %256 %260 + %262 = OpAccessChain %_ptr_Function_float %M %166 %166 + %263 = OpLoad %float %262 + %264 = OpFDiv %float %261 %263 + %266 = OpLoad %float %viewNear + %265 = OpFNegate %float %266 + %267 = OpAccessChain %_ptr_Function_float %ceilCoord %uint_1 + %268 = OpLoad %float %267 + %269 = OpFMul %float %265 %268 + %270 = OpAccessChain %_ptr_Function_float %M %int_2 %int_1 + %271 = OpLoad %float %270 + %272 = OpLoad %float %viewNear + %273 = OpFMul %float %271 %272 + %274 = OpFSub %float %269 %273 + %275 = OpAccessChain %_ptr_Function_float %M %int_1 %int_1 + %276 = OpLoad %float %275 + %277 = OpFDiv %float %274 %276 + %278 = OpCompositeConstruct %v2float %264 %277 + OpStore %viewCeilCoord %278 + %280 = OpAccessChain %_ptr_Function_v4float %frustumPlanes %166 + %282 = OpAccessChain %_ptr_Function_float %viewFloorCoord %uint_0 + %283 = OpLoad %float %282 + %281 = OpFNegate %float %283 + %284 = OpLoad %float %viewNear + %285 = OpFDiv %float %281 %284 + %286 = OpCompositeConstruct %v4float %float_1 %101 %285 %101 + OpStore %280 %286 + %287 = OpAccessChain %_ptr_Function_v4float %frustumPlanes %int_1 + %288 = OpAccessChain %_ptr_Function_float %viewCeilCoord %uint_0 + %289 = OpLoad %float %288 + %290 = OpLoad %float %viewNear + %291 = OpFDiv %float %289 %290 + %292 = OpCompositeConstruct %v4float %float_n1 %101 %291 %101 + OpStore %287 %292 + %293 = OpAccessChain %_ptr_Function_v4float %frustumPlanes %int_2 + %295 = OpAccessChain %_ptr_Function_float %viewFloorCoord %uint_1 + %296 = OpLoad %float %295 + %294 = OpFNegate %float %296 + %297 = OpLoad %float %viewNear + %298 = OpFDiv %float %294 %297 + %299 = OpCompositeConstruct %v4float %101 %float_1 %298 %101 + OpStore %293 %299 + %300 = OpAccessChain %_ptr_Function_v4float %frustumPlanes %int_3 + %301 = OpAccessChain %_ptr_Function_float %viewCeilCoord %uint_1 + %302 = OpLoad %float %301 + %303 = OpLoad %float %viewNear + %304 = OpFDiv %float %302 %303 + %305 = OpCompositeConstruct %v4float %101 %float_n1 %304 %101 + OpStore %300 %305 + OpStore %dp %101 + OpStore %i %36 + OpBranch %308 + %308 = OpLabel + OpLoopMerge %309 %310 None + OpBranch %311 + %311 = OpLabel + %313 = OpLoad %uint %i + %314 = OpULessThan %bool %313 %uint_6 + %312 = OpLogicalNot %bool %314 + OpSelectionMerge %315 None + OpBranchConditional %312 %316 %315 + %316 = OpLabel + OpBranch %309 + %315 = OpLabel + %318 = OpLoad %uint %i + %319 = OpAccessChain %_ptr_Function_float %frustumPlanes %318 %uint_0 + %320 = OpLoad %float %319 + %321 = OpFOrdGreaterThan %bool %320 %101 + OpSelectionMerge %322 None + OpBranchConditional %321 %323 %324 + %323 = OpLabel + %325 = OpAccessChain %_ptr_Function_float %p %uint_0 + %326 = OpAccessChain %_ptr_Function_float %boxMax %uint_0 + %327 = OpLoad %float %326 + OpStore %325 %327 + OpBranch %322 + %324 = OpLabel + %328 = OpAccessChain %_ptr_Function_float %p %uint_0 + %329 = OpAccessChain %_ptr_Function_float %boxMin %uint_0 + %330 = OpLoad %float %329 + OpStore %328 %330 + OpBranch %322 + %322 = OpLabel + %331 = OpLoad %uint %i + %332 = OpAccessChain %_ptr_Function_float %frustumPlanes %331 %uint_1 + %333 = OpLoad %float %332 + %334 = OpFOrdGreaterThan %bool %333 %101 + OpSelectionMerge %335 None + OpBranchConditional %334 %336 %337 + %336 = OpLabel + %338 = OpAccessChain %_ptr_Function_float %p %uint_1 + %339 = OpAccessChain %_ptr_Function_float %boxMax %uint_1 + %340 = OpLoad %float %339 + OpStore %338 %340 + OpBranch %335 + %337 = OpLabel + %341 = OpAccessChain %_ptr_Function_float %p %uint_1 + %342 = OpAccessChain %_ptr_Function_float %boxMin %uint_1 + %343 = OpLoad %float %342 + OpStore %341 %343 + OpBranch %335 + %335 = OpLabel + %344 = OpLoad %uint %i + %345 = OpAccessChain %_ptr_Function_float %frustumPlanes %344 %uint_2 + %346 = OpLoad %float %345 + %347 = OpFOrdGreaterThan %bool %346 %101 + OpSelectionMerge %348 None + OpBranchConditional %347 %349 %350 + %349 = OpLabel + %351 = OpAccessChain %_ptr_Function_float %p %uint_2 + %352 = OpAccessChain %_ptr_Function_float %boxMax %uint_2 + %353 = OpLoad %float %352 + OpStore %351 %353 + OpBranch %348 + %350 = OpLabel + %354 = OpAccessChain %_ptr_Function_float %p %uint_2 + %355 = OpAccessChain %_ptr_Function_float %boxMin %uint_2 + %356 = OpLoad %float %355 + OpStore %354 %356 + OpBranch %348 + %348 = OpLabel + %357 = OpAccessChain %_ptr_Function_float %p %uint_3 + OpStore %357 %float_1 + %358 = OpLoad %float %dp + %361 = OpLoad %v4float %p + %362 = OpLoad %uint %i + %363 = OpAccessChain %_ptr_Function_v4float %frustumPlanes %362 + %364 = OpLoad %v4float %363 + %360 = OpDot %float %361 %364 + %359 = OpExtInst %float %60 NMin %101 %360 + %365 = OpFAdd %float %358 %359 + OpStore %dp %365 OpBranch %310 %310 = OpLabel - OpLoopMerge %311 %312 None - OpBranch %313 - %313 = OpLabel - %315 = OpLoad %uint %i - %316 = OpULessThan %bool %315 %uint_6 - %314 = OpLogicalNot %bool %316 - OpSelectionMerge %317 None - OpBranchConditional %314 %318 %317 - %318 = OpLabel - OpBranch %311 - %317 = OpLabel - %320 = OpLoad %uint %i - %321 = OpAccessChain %_ptr_Function_float %frustumPlanes %320 %uint_0 - %322 = OpLoad %float %321 - %323 = OpFOrdGreaterThan %bool %322 %float_0 - OpSelectionMerge %324 None - OpBranchConditional %323 %325 %326 - %325 = OpLabel - %327 = OpAccessChain %_ptr_Function_float %p %uint_0 - %328 = OpAccessChain %_ptr_Function_float %boxMax %uint_0 - %329 = OpLoad %float %328 - OpStore %327 %329 - OpBranch %324 - %326 = OpLabel - %330 = OpAccessChain %_ptr_Function_float %p %uint_0 - %331 = OpAccessChain %_ptr_Function_float %boxMin %uint_0 - %332 = OpLoad %float %331 - OpStore %330 %332 - OpBranch %324 - %324 = OpLabel - %333 = OpLoad %uint %i - %334 = OpAccessChain %_ptr_Function_float %frustumPlanes %333 %uint_1 - %335 = OpLoad %float %334 - %336 = OpFOrdGreaterThan %bool %335 %float_0 - OpSelectionMerge %337 None - OpBranchConditional %336 %338 %339 - %338 = OpLabel - %340 = OpAccessChain %_ptr_Function_float %p %uint_1 - %341 = OpAccessChain %_ptr_Function_float %boxMax %uint_1 - %342 = OpLoad %float %341 - OpStore %340 %342 - OpBranch %337 - %339 = OpLabel - %343 = OpAccessChain %_ptr_Function_float %p %uint_1 - %344 = OpAccessChain %_ptr_Function_float %boxMin %uint_1 - %345 = OpLoad %float %344 - OpStore %343 %345 - OpBranch %337 - %337 = OpLabel - %346 = OpLoad %uint %i - %347 = OpAccessChain %_ptr_Function_float %frustumPlanes %346 %uint_2 - %348 = OpLoad %float %347 - %349 = OpFOrdGreaterThan %bool %348 %float_0 - OpSelectionMerge %350 None - OpBranchConditional %349 %351 %352 - %351 = OpLabel - %353 = OpAccessChain %_ptr_Function_float %p %uint_2 - %354 = OpAccessChain %_ptr_Function_float %boxMax %uint_2 - %355 = OpLoad %float %354 - OpStore %353 %355 - OpBranch %350 - %352 = OpLabel - %356 = OpAccessChain %_ptr_Function_float %p %uint_2 - %357 = OpAccessChain %_ptr_Function_float %boxMin %uint_2 - %358 = OpLoad %float %357 - OpStore %356 %358 - OpBranch %350 - %350 = OpLabel - %359 = OpAccessChain %_ptr_Function_float %p %uint_3 - OpStore %359 %float_1 - %360 = OpLoad %float %dp - %363 = OpLoad %v4float %p - %364 = OpLoad %uint %i - %365 = OpAccessChain %_ptr_Function_v4float %frustumPlanes %364 - %366 = OpLoad %v4float %365 - %362 = OpDot %float %363 %366 - %361 = OpExtInst %float %60 NMin %float_0 %362 - %367 = OpFAdd %float %360 %361 - OpStore %dp %367 - OpBranch %312 - %312 = OpLabel - %368 = OpLoad %uint %i - %369 = OpIAdd %uint %368 %uint_1 - OpStore %i %369 - OpBranch %310 - %311 = OpLabel - %370 = OpLoad %float %dp - %371 = OpFOrdGreaterThanEqual %bool %370 %float_0 - OpSelectionMerge %372 None - OpBranchConditional %371 %373 %372 - %373 = OpLabel - %375 = OpLoad %int %x - %376 = OpLoad %int %y - %377 = OpIMul %int %376 %int_2 - %378 = OpIAdd %int %375 %377 - %374 = OpBitcast %uint %378 - OpStore %tileId %374 - %380 = OpLoad %uint %tileId - %381 = OpULessThan %bool %380 %uint_0 - OpSelectionMerge %382 None - OpBranchConditional %381 %382 %383 - %383 = OpLabel - %384 = OpLoad %uint %tileId - %385 = OpAccessChain %_ptr_Uniform_uint %config %uint_1 - %386 = OpLoad %uint %385 - %387 = OpUGreaterThanEqual %bool %384 %386 - OpBranch %382 - %382 = OpLabel - %388 = OpPhi %bool %381 %373 %387 %383 - OpSelectionMerge %389 None - OpBranchConditional %388 %390 %389 - %390 = OpLabel - OpBranch %183 - %389 = OpLabel - %393 = OpLoad %uint %tileId - %395 = OpAccessChain %_ptr_StorageBuffer_uint %tileLightId %uint_0 %393 %uint_0 - %391 = OpAtomicIAdd %uint %395 %uint_1 %uint_0 %uint_1 - OpStore %offset %391 - %397 = OpLoad %uint %offset - %398 = OpAccessChain %_ptr_Uniform_uint %config %uint_4 - %399 = OpLoad %uint %398 - %400 = OpUGreaterThanEqual %bool %397 %399 - OpSelectionMerge %401 None - OpBranchConditional %400 %402 %401 - %402 = OpLabel - OpBranch %183 - %401 = OpLabel - %403 = OpLoad %uint %tileId - %404 = OpLoad %uint %offset - %406 = OpAccessChain %_ptr_StorageBuffer_uint_0 %tileLightId %uint_0 %403 %uint_1 %404 - %407 = OpCompositeExtract %uint %GlobalInvocationID 0 - OpStore %406 %407 - OpBranch %372 - %372 = OpLabel - OpBranch %183 - %183 = OpLabel - %408 = OpLoad %int %x - %409 = OpIAdd %int %408 %int_1 - OpStore %x %409 + %366 = OpLoad %uint %i + %367 = OpIAdd %uint %366 %uint_1 + OpStore %i %367 + OpBranch %308 + %309 = OpLabel + %368 = OpLoad %float %dp + %369 = OpFOrdGreaterThanEqual %bool %368 %101 + OpSelectionMerge %370 None + OpBranchConditional %369 %371 %370 + %371 = OpLabel + %373 = OpLoad %int %x + %374 = OpLoad %int %y + %375 = OpIMul %int %374 %int_2 + %376 = OpIAdd %int %373 %375 + %372 = OpBitcast %uint %376 + OpStore %tileId %372 + %378 = OpLoad %uint %tileId + %379 = OpULessThan %bool %378 %36 + OpSelectionMerge %380 None + OpBranchConditional %379 %380 %381 + %381 = OpLabel + %382 = OpLoad %uint %tileId + %383 = OpAccessChain %_ptr_Uniform_uint %config %uint_1 + %384 = OpLoad %uint %383 + %385 = OpUGreaterThanEqual %bool %382 %384 + OpBranch %380 + %380 = OpLabel + %386 = OpPhi %bool %379 %371 %385 %381 + OpSelectionMerge %387 None + OpBranchConditional %386 %388 %387 + %388 = OpLabel OpBranch %181 - %182 = OpLabel - OpBranch %173 - %173 = OpLabel - %410 = OpLoad %int %y - %411 = OpIAdd %int %410 %int_1 - OpStore %y %411 + %387 = OpLabel + %391 = OpLoad %uint %tileId + %393 = OpAccessChain %_ptr_StorageBuffer_uint %tileLightId %uint_0 %391 %uint_0 + %389 = OpAtomicIAdd %uint %393 %uint_1 %uint_0 %uint_1 + OpStore %offset %389 + %395 = OpLoad %uint %offset + %396 = OpAccessChain %_ptr_Uniform_uint %config %uint_4 + %397 = OpLoad %uint %396 + %398 = OpUGreaterThanEqual %bool %395 %397 + OpSelectionMerge %399 None + OpBranchConditional %398 %400 %399 + %400 = OpLabel + OpBranch %181 + %399 = OpLabel + %401 = OpLoad %uint %tileId + %402 = OpLoad %uint %offset + %404 = OpAccessChain %_ptr_StorageBuffer_uint_0 %tileLightId %uint_0 %401 %uint_1 %402 + %405 = OpCompositeExtract %uint %GlobalInvocationID 0 + OpStore %404 %405 + OpBranch %370 + %370 = OpLabel + OpBranch %181 + %181 = OpLabel + %406 = OpLoad %int %x + %407 = OpIAdd %int %406 %int_1 + OpStore %x %407 + OpBranch %179 + %180 = OpLabel OpBranch %171 - %172 = OpLabel + %171 = OpLabel + %408 = OpLoad %int %y + %409 = OpIAdd %int %408 %int_1 + OpStore %y %409 + OpBranch %169 + %170 = OpLabel OpReturn OpFunctionEnd - %main = OpFunction %void None %412 - %414 = OpLabel - %416 = OpLoad %v3uint %GlobalInvocationID_1 - %415 = OpFunctionCall %void %main_inner %416 + %main = OpFunction %void None %410 + %412 = OpLabel + %414 = OpLoad %v3uint %GlobalInvocationID_1 + %413 = OpFunctionCall %void %main_inner %414 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/1369.wgsl.expected.spvasm b/test/tint/bug/tint/1369.wgsl.expected.spvasm index e3ece9c26b..f9013117ed 100644 --- a/test/tint/bug/tint/1369.wgsl.expected.spvasm +++ b/test/tint/bug/tint/1369.wgsl.expected.spvasm @@ -9,7 +9,7 @@ bug/tint/1369.wgsl:9:9 warning: code is unreachable ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 23 +; Bound: 22 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -21,35 +21,34 @@ bug/tint/1369.wgsl:9:9 warning: code is unreachable OpName %f "f" OpName %v "v" %bool = OpTypeBool - %false = OpConstantFalse %bool + %2 = OpConstantNull %bool %_ptr_Private_bool = OpTypePointer Private %bool -%tint_discard = OpVariable %_ptr_Private_bool Private %false +%tint_discard = OpVariable %_ptr_Private_bool Private %2 %5 = OpTypeFunction %bool %true = OpConstantTrue %bool - %9 = OpConstantNull %bool %void = OpTypeVoid - %10 = OpTypeFunction %void + %9 = OpTypeFunction %void %_ptr_Function_bool = OpTypePointer Function %bool %call_discard = OpFunction %bool None %5 %7 = OpLabel OpStore %tint_discard %true - OpReturnValue %9 + OpReturnValue %2 OpFunctionEnd -%tint_discard_func = OpFunction %void None %10 - %13 = OpLabel +%tint_discard_func = OpFunction %void None %9 + %12 = OpLabel OpKill OpFunctionEnd - %f = OpFunction %void None %10 - %15 = OpLabel - %v = OpVariable %_ptr_Function_bool Function %9 - %16 = OpFunctionCall %bool %call_discard - OpStore %v %16 - %19 = OpLoad %bool %tint_discard - OpSelectionMerge %20 None - OpBranchConditional %19 %21 %20 - %21 = OpLabel - %22 = OpFunctionCall %void %tint_discard_func - OpReturn + %f = OpFunction %void None %9 + %14 = OpLabel + %v = OpVariable %_ptr_Function_bool Function %2 + %15 = OpFunctionCall %bool %call_discard + OpStore %v %15 + %18 = OpLoad %bool %tint_discard + OpSelectionMerge %19 None + OpBranchConditional %18 %20 %19 %20 = OpLabel + %21 = OpFunctionCall %void %tint_discard_func + OpReturn + %19 = OpLabel OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/1385.wgsl.expected.spvasm b/test/tint/bug/tint/1385.wgsl.expected.spvasm index a7f1b74341..6b9da4dd90 100644 --- a/test/tint/bug/tint/1385.wgsl.expected.spvasm +++ b/test/tint/bug/tint/1385.wgsl.expected.spvasm @@ -26,13 +26,13 @@ %6 = OpTypeFunction %int %uint = OpTypeInt 32 0 %uint_0 = OpConstant %uint 0 - %int_0 = OpConstant %int 0 + %11 = OpConstantNull %int %_ptr_StorageBuffer_int = OpTypePointer StorageBuffer %int %void = OpTypeVoid %15 = OpTypeFunction %void %foo = OpFunction %int None %6 %8 = OpLabel - %13 = OpAccessChain %_ptr_StorageBuffer_int %data %uint_0 %int_0 + %13 = OpAccessChain %_ptr_StorageBuffer_int %data %uint_0 %11 %14 = OpLoad %int %13 OpReturnValue %14 OpFunctionEnd diff --git a/test/tint/bug/tint/1520.spvasm.expected.spvasm b/test/tint/bug/tint/1520.spvasm.expected.spvasm index ad913296c2..b5fd273820 100644 --- a/test/tint/bug/tint/1520.spvasm.expected.spvasm +++ b/test/tint/bug/tint/1520.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 175 +; Bound: 170 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -97,30 +97,25 @@ %uint_0 = OpConstant %uint 0 %_ptr_Uniform_float = OpTypePointer Uniform %float %true = OpConstantTrue %bool - %false = OpConstantFalse %bool - %int_0 = OpConstant %int 0 - %53 = OpConstantComposite %v4int %int_0 %int_0 %int_0 %int_0 %v4bool = OpTypeVector %bool 4 %int_1 = OpConstant %int 1 - %62 = OpConstantComposite %v4int %int_1 %int_1 %int_1 %int_1 + %59 = OpConstantComposite %v4int %int_1 %int_1 %int_1 %int_1 %int_2 = OpConstant %int 2 - %74 = OpConstantComposite %v4int %int_2 %int_2 %int_2 %int_2 + %71 = OpConstantComposite %v4int %int_2 %int_2 %int_2 %int_2 %void = OpTypeVoid - %85 = OpTypeFunction %void + %82 = OpTypeFunction %void %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Function_float = OpTypePointer Function %float - %94 = OpConstantNull %float - %float_0 = OpConstant %float 0 - %113 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 + %91 = OpConstantNull %float %float_1 = OpConstant %float 1 - %121 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 + %116 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %float_2 = OpConstant %float 2 - %133 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 + %128 = OpConstantComposite %v4float %float_2 %float_2 %float_2 %float_2 %uint_2 = OpConstant %uint 2 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %uint_1 = OpConstant %uint 1 %main_out = OpTypeStruct %v4float - %160 = OpTypeFunction %main_out %bool %v4float + %155 = OpTypeFunction %main_out %bool %v4float %test_int_S1_c0_b = OpFunction %bool None %22 %24 = OpLabel %unknown = OpVariable %_ptr_Function_int Function %28 @@ -137,72 +132,72 @@ %46 = OpConvertFToS %int %45 OpStore %unknown %46 OpStore %ok %true - OpStore %x_41_phi %false - OpSelectionMerge %49 None - OpBranchConditional %true %50 %49 - %50 = OpLabel - %54 = OpCompositeConstruct %v4int %46 %46 %46 %46 - %55 = OpSDiv %v4int %53 %54 - %56 = OpIEqual %v4bool %55 %53 - %51 = OpAll %bool %56 - OpStore %x_40 %51 - %58 = OpLoad %bool %x_40 - OpStore %x_41_phi %58 - OpBranch %49 + OpStore %x_41_phi %20 + OpSelectionMerge %48 None + OpBranchConditional %true %49 %48 %49 = OpLabel - %59 = OpLoad %bool %x_41_phi - OpStore %ok %59 - %60 = OpCompositeConstruct %v4int %46 %46 %46 %46 + %51 = OpCompositeConstruct %v4int %46 %46 %46 %46 + %52 = OpSDiv %v4int %34 %51 + %53 = OpIEqual %v4bool %52 %34 + %50 = OpAll %bool %53 + OpStore %x_40 %50 + %55 = OpLoad %bool %x_40 + OpStore %x_41_phi %55 + OpBranch %48 + %48 = OpLabel + %56 = OpLoad %bool %x_41_phi + OpStore %ok %56 + %57 = OpCompositeConstruct %v4int %46 %46 %46 %46 + OpStore %val %57 + %60 = OpIAdd %v4int %57 %59 OpStore %val %60 - %63 = OpIAdd %v4int %60 %62 + %61 = OpISub %v4int %60 %59 + OpStore %val %61 + %62 = OpIAdd %v4int %61 %59 + OpStore %val %62 + %63 = OpISub %v4int %62 %59 OpStore %val %63 - %64 = OpISub %v4int %63 %62 - OpStore %val %64 - %65 = OpIAdd %v4int %64 %62 - OpStore %val %65 - %66 = OpISub %v4int %65 %62 - OpStore %val %66 - OpStore %x_55_phi %false - OpSelectionMerge %67 None - OpBranchConditional %59 %68 %67 - %68 = OpLabel - %70 = OpIEqual %v4bool %66 %60 - %69 = OpAll %bool %70 - OpStore %x_54 %69 - %71 = OpLoad %bool %x_54 - OpStore %x_55_phi %71 - OpBranch %67 - %67 = OpLabel - %72 = OpLoad %bool %x_55_phi - OpStore %ok %72 - %75 = OpIMul %v4int %66 %74 + OpStore %x_55_phi %20 + OpSelectionMerge %64 None + OpBranchConditional %56 %65 %64 + %65 = OpLabel + %67 = OpIEqual %v4bool %63 %57 + %66 = OpAll %bool %67 + OpStore %x_54 %66 + %68 = OpLoad %bool %x_54 + OpStore %x_55_phi %68 + OpBranch %64 + %64 = OpLabel + %69 = OpLoad %bool %x_55_phi + OpStore %ok %69 + %72 = OpIMul %v4int %63 %71 + OpStore %val %72 + %73 = OpSDiv %v4int %72 %71 + OpStore %val %73 + %74 = OpIMul %v4int %73 %71 + OpStore %val %74 + %75 = OpSDiv %v4int %74 %71 OpStore %val %75 - %76 = OpSDiv %v4int %75 %74 - OpStore %val %76 - %77 = OpIMul %v4int %76 %74 - OpStore %val %77 - %78 = OpSDiv %v4int %77 %74 - OpStore %val %78 - OpStore %x_66_phi %false - OpSelectionMerge %79 None - OpBranchConditional %72 %80 %79 - %80 = OpLabel - %82 = OpIEqual %v4bool %78 %60 - %81 = OpAll %bool %82 - OpStore %x_65 %81 - %83 = OpLoad %bool %x_65 - OpStore %x_66_phi %83 - OpBranch %79 - %79 = OpLabel - %84 = OpLoad %bool %x_66_phi - OpStore %ok %84 - OpReturnValue %84 + OpStore %x_66_phi %20 + OpSelectionMerge %76 None + OpBranchConditional %69 %77 %76 + %77 = OpLabel + %79 = OpIEqual %v4bool %75 %57 + %78 = OpAll %bool %79 + OpStore %x_65 %78 + %80 = OpLoad %bool %x_65 + OpStore %x_66_phi %80 + OpBranch %76 + %76 = OpLabel + %81 = OpLoad %bool %x_66_phi + OpStore %ok %81 + OpReturnValue %81 OpFunctionEnd - %main_1 = OpFunction %void None %85 - %88 = OpLabel + %main_1 = OpFunction %void None %82 + %85 = OpLabel %outputColor_S0 = OpVariable %_ptr_Function_v4float Function %10 %output_S1 = OpVariable %_ptr_Function_v4float Function %10 -%x_8_unknown = OpVariable %_ptr_Function_float Function %94 +%x_8_unknown = OpVariable %_ptr_Function_float Function %91 %x_9_ok = OpVariable %_ptr_Function_bool Function %20 %x_10_val = OpVariable %_ptr_Function_v4float Function %10 %x_116 = OpVariable %_ptr_Function_v4float Function %10 @@ -214,117 +209,117 @@ %x_100_phi = OpVariable %_ptr_Function_bool Function %20 %x_111_phi = OpVariable %_ptr_Function_bool Function %20 %x_115_phi = OpVariable %_ptr_Function_bool Function %20 - %106 = OpLoad %v4float %vcolor_S0 - OpStore %outputColor_S0 %106 - %107 = OpAccessChain %_ptr_Uniform_float %x_4 %uint_0 - %108 = OpLoad %float %107 - OpStore %x_8_unknown %108 + %103 = OpLoad %v4float %vcolor_S0 + OpStore %outputColor_S0 %103 + %104 = OpAccessChain %_ptr_Uniform_float %x_4 %uint_0 + %105 = OpLoad %float %104 + OpStore %x_8_unknown %105 OpStore %x_9_ok %true - OpStore %x_87_phi %false - OpSelectionMerge %109 None - OpBranchConditional %true %110 %109 - %110 = OpLabel - %114 = OpCompositeConstruct %v4float %108 %108 %108 %108 - %115 = OpFDiv %v4float %113 %114 - %116 = OpFOrdEqual %v4bool %115 %113 - %111 = OpAll %bool %116 - OpStore %x_86 %111 - %117 = OpLoad %bool %x_86 - OpStore %x_87_phi %117 - OpBranch %109 - %109 = OpLabel - %118 = OpLoad %bool %x_87_phi - OpStore %x_9_ok %118 - %119 = OpCompositeConstruct %v4float %108 %108 %108 %108 + OpStore %x_87_phi %20 + OpSelectionMerge %106 None + OpBranchConditional %true %107 %106 + %107 = OpLabel + %109 = OpCompositeConstruct %v4float %105 %105 %105 %105 + %110 = OpFDiv %v4float %10 %109 + %111 = OpFOrdEqual %v4bool %110 %10 + %108 = OpAll %bool %111 + OpStore %x_86 %108 + %112 = OpLoad %bool %x_86 + OpStore %x_87_phi %112 + OpBranch %106 + %106 = OpLabel + %113 = OpLoad %bool %x_87_phi + OpStore %x_9_ok %113 + %114 = OpCompositeConstruct %v4float %105 %105 %105 %105 + OpStore %x_10_val %114 + %117 = OpFAdd %v4float %114 %116 + OpStore %x_10_val %117 + %118 = OpFSub %v4float %117 %116 + OpStore %x_10_val %118 + %119 = OpFAdd %v4float %118 %116 OpStore %x_10_val %119 - %122 = OpFAdd %v4float %119 %121 - OpStore %x_10_val %122 - %123 = OpFSub %v4float %122 %121 - OpStore %x_10_val %123 - %124 = OpFAdd %v4float %123 %121 - OpStore %x_10_val %124 - %125 = OpFSub %v4float %124 %121 - OpStore %x_10_val %125 - OpStore %x_100_phi %false - OpSelectionMerge %126 None - OpBranchConditional %118 %127 %126 - %127 = OpLabel - %129 = OpFOrdEqual %v4bool %125 %119 - %128 = OpAll %bool %129 - OpStore %x_99 %128 - %130 = OpLoad %bool %x_99 - OpStore %x_100_phi %130 - OpBranch %126 - %126 = OpLabel - %131 = OpLoad %bool %x_100_phi - OpStore %x_9_ok %131 - %134 = OpFMul %v4float %125 %133 - OpStore %x_10_val %134 - %135 = OpFDiv %v4float %134 %133 - OpStore %x_10_val %135 - %136 = OpFMul %v4float %135 %133 - OpStore %x_10_val %136 - %137 = OpFDiv %v4float %136 %133 - OpStore %x_10_val %137 - OpStore %x_111_phi %false - OpSelectionMerge %138 None - OpBranchConditional %131 %139 %138 + %120 = OpFSub %v4float %119 %116 + OpStore %x_10_val %120 + OpStore %x_100_phi %20 + OpSelectionMerge %121 None + OpBranchConditional %113 %122 %121 + %122 = OpLabel + %124 = OpFOrdEqual %v4bool %120 %114 + %123 = OpAll %bool %124 + OpStore %x_99 %123 + %125 = OpLoad %bool %x_99 + OpStore %x_100_phi %125 + OpBranch %121 + %121 = OpLabel + %126 = OpLoad %bool %x_100_phi + OpStore %x_9_ok %126 + %129 = OpFMul %v4float %120 %128 + OpStore %x_10_val %129 + %130 = OpFDiv %v4float %129 %128 + OpStore %x_10_val %130 + %131 = OpFMul %v4float %130 %128 + OpStore %x_10_val %131 + %132 = OpFDiv %v4float %131 %128 + OpStore %x_10_val %132 + OpStore %x_111_phi %20 + OpSelectionMerge %133 None + OpBranchConditional %126 %134 %133 + %134 = OpLabel + %136 = OpFOrdEqual %v4bool %132 %114 + %135 = OpAll %bool %136 + OpStore %x_110 %135 + %137 = OpLoad %bool %x_110 + OpStore %x_111_phi %137 + OpBranch %133 + %133 = OpLabel + %138 = OpLoad %bool %x_111_phi + OpStore %x_9_ok %138 + OpStore %x_115_phi %20 + OpSelectionMerge %139 None + OpBranchConditional %138 %140 %139 + %140 = OpLabel + %141 = OpFunctionCall %bool %test_int_S1_c0_b + OpStore %x_114 %141 + %142 = OpLoad %bool %x_114 + OpStore %x_115_phi %142 + OpBranch %139 %139 = OpLabel - %141 = OpFOrdEqual %v4bool %137 %119 - %140 = OpAll %bool %141 - OpStore %x_110 %140 - %142 = OpLoad %bool %x_110 - OpStore %x_111_phi %142 - OpBranch %138 - %138 = OpLabel - %143 = OpLoad %bool %x_111_phi - OpStore %x_9_ok %143 - OpStore %x_115_phi %false + %143 = OpLoad %bool %x_115_phi OpSelectionMerge %144 None - OpBranchConditional %143 %145 %144 + OpBranchConditional %143 %145 %146 %145 = OpLabel - %146 = OpFunctionCall %bool %test_int_S1_c0_b - OpStore %x_114 %146 - %147 = OpLoad %bool %x_114 - OpStore %x_115_phi %147 + %149 = OpAccessChain %_ptr_Uniform_v4float %x_4 %uint_2 + %150 = OpLoad %v4float %149 + OpStore %x_116 %150 + OpBranch %144 + %146 = OpLabel + %152 = OpAccessChain %_ptr_Uniform_v4float %x_4 %uint_1 + %153 = OpLoad %v4float %152 + OpStore %x_116 %153 OpBranch %144 %144 = OpLabel - %148 = OpLoad %bool %x_115_phi - OpSelectionMerge %149 None - OpBranchConditional %148 %150 %151 - %150 = OpLabel - %154 = OpAccessChain %_ptr_Uniform_v4float %x_4 %uint_2 - %155 = OpLoad %v4float %154 - OpStore %x_116 %155 - OpBranch %149 - %151 = OpLabel - %157 = OpAccessChain %_ptr_Uniform_v4float %x_4 %uint_1 - %158 = OpLoad %v4float %157 - OpStore %x_116 %158 - OpBranch %149 - %149 = OpLabel - %159 = OpLoad %v4float %x_116 - OpStore %output_S1 %159 - OpStore %sk_FragColor %159 + %154 = OpLoad %v4float %x_116 + OpStore %output_S1 %154 + OpStore %sk_FragColor %154 OpReturn OpFunctionEnd - %main_inner = OpFunction %main_out None %160 + %main_inner = OpFunction %main_out None %155 %sk_Clockwise_param = OpFunctionParameter %bool %vcolor_S0_param = OpFunctionParameter %v4float - %165 = OpLabel + %160 = OpLabel OpStore %sk_Clockwise %sk_Clockwise_param OpStore %vcolor_S0 %vcolor_S0_param - %166 = OpFunctionCall %void %main_1 - %167 = OpLoad %v4float %sk_FragColor - %168 = OpCompositeConstruct %main_out %167 - OpReturnValue %168 + %161 = OpFunctionCall %void %main_1 + %162 = OpLoad %v4float %sk_FragColor + %163 = OpCompositeConstruct %main_out %162 + OpReturnValue %163 OpFunctionEnd - %main = OpFunction %void None %85 - %170 = OpLabel - %172 = OpLoad %bool %sk_Clockwise_param_1 - %173 = OpLoad %v4float %vcolor_S0_param_1 - %171 = OpFunctionCall %main_out %main_inner %172 %173 - %174 = OpCompositeExtract %v4float %171 0 - OpStore %sk_FragColor_1_1 %174 + %main = OpFunction %void None %82 + %165 = OpLabel + %167 = OpLoad %bool %sk_Clockwise_param_1 + %168 = OpLoad %v4float %vcolor_S0_param_1 + %166 = OpFunctionCall %main_out %main_inner %167 %168 + %169 = OpCompositeExtract %v4float %166 0 + OpStore %sk_FragColor_1_1 %169 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/1541.wgsl.expected.spvasm b/test/tint/bug/tint/1541.wgsl.expected.spvasm index 415f251f31..af44c3be67 100644 --- a/test/tint/bug/tint/1541.wgsl.expected.spvasm +++ b/test/tint/bug/tint/1541.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 13 +; Bound: 12 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -12,15 +12,14 @@ %void = OpTypeVoid %1 = OpTypeFunction %void %bool = OpTypeBool - %false = OpConstantFalse %bool + %7 = OpConstantNull %bool %true = OpConstantTrue %bool %_ptr_Function_bool = OpTypePointer Function %bool - %12 = OpConstantNull %bool %main = OpFunction %void None %1 %4 = OpLabel - %v = OpVariable %_ptr_Function_bool Function %12 + %v = OpVariable %_ptr_Function_bool Function %7 %9 = OpLogicalAnd %bool %true %true - %5 = OpSelect %bool %false %true %9 + %5 = OpSelect %bool %7 %true %9 OpStore %v %5 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/1573.wgsl.expected.spvasm b/test/tint/bug/tint/1573.wgsl.expected.spvasm index 1d2672bc88..84757262c0 100644 --- a/test/tint/bug/tint/1573.wgsl.expected.spvasm +++ b/test/tint/bug/tint/1573.wgsl.expected.spvasm @@ -41,7 +41,7 @@ OpStore %value %uint_42 %20 = OpAccessChain %_ptr_StorageBuffer_uint %a %uint_0 %21 = OpLoad %uint %value - %22 = OpAtomicCompareExchange %uint %20 %uint_1 %uint_0 %uint_0 %21 %uint_0 + %22 = OpAtomicCompareExchange %uint %20 %uint_1 %uint_0 %uint_0 %21 %12 %23 = OpIEqual %bool %22 %21 %13 = OpCompositeConstruct %__atomic_compare_exchange_resultu32 %22 %23 OpReturn diff --git a/test/tint/bug/tint/221.wgsl.expected.spvasm b/test/tint/bug/tint/221.wgsl.expected.spvasm index 955f7d0d27..486cb6af88 100644 --- a/test/tint/bug/tint/221.wgsl.expected.spvasm +++ b/test/tint/bug/tint/221.wgsl.expected.spvasm @@ -27,44 +27,44 @@ %b = OpVariable %_ptr_StorageBuffer_Buf StorageBuffer %void = OpTypeVoid %7 = OpTypeFunction %void - %uint_0 = OpConstant %uint 0 + %11 = OpConstantNull %uint %_ptr_Function_uint = OpTypePointer Function %uint - %14 = OpConstantNull %uint + %uint_0 = OpConstant %uint 0 %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint %bool = OpTypeBool %uint_2 = OpConstant %uint 2 %uint_1 = OpConstant %uint 1 %main = OpFunction %void None %7 %10 = OpLabel - %i = OpVariable %_ptr_Function_uint Function %14 - OpStore %i %uint_0 - OpBranch %15 - %15 = OpLabel - OpLoopMerge %16 %17 None - OpBranch %18 - %18 = OpLabel - %19 = OpLoad %uint %i + %i = OpVariable %_ptr_Function_uint Function %11 + OpStore %i %11 + OpBranch %14 + %14 = OpLabel + OpLoopMerge %15 %16 None + OpBranch %17 + %17 = OpLabel + %18 = OpLoad %uint %i %21 = OpAccessChain %_ptr_StorageBuffer_uint %b %uint_0 %22 = OpLoad %uint %21 - %23 = OpUGreaterThanEqual %bool %19 %22 + %23 = OpUGreaterThanEqual %bool %18 %22 OpSelectionMerge %25 None OpBranchConditional %23 %26 %25 %26 = OpLabel - OpBranch %16 + OpBranch %15 %25 = OpLabel %27 = OpLoad %uint %i %28 = OpLoad %uint %i %30 = OpUMod %uint %28 %uint_2 - %31 = OpIEqual %bool %30 %uint_0 + %31 = OpIEqual %bool %30 %11 OpSelectionMerge %32 None OpBranchConditional %31 %33 %32 %33 = OpLabel - OpBranch %17 + OpBranch %16 %32 = OpLabel %35 = OpAccessChain %_ptr_StorageBuffer_uint %b %uint_1 %27 - OpStore %35 %uint_0 - OpBranch %17 - %17 = OpLabel + OpStore %35 %11 + OpBranch %16 + %16 = OpLabel %36 = OpAccessChain %_ptr_StorageBuffer_uint %b %uint_1 %27 %37 = OpAccessChain %_ptr_StorageBuffer_uint %b %uint_1 %27 %38 = OpLoad %uint %37 @@ -73,7 +73,7 @@ %40 = OpLoad %uint %i %41 = OpIAdd %uint %40 %uint_1 OpStore %i %41 - OpBranch %15 - %16 = OpLabel + OpBranch %14 + %15 = OpLabel OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/403.wgsl.expected.spvasm b/test/tint/bug/tint/403.wgsl.expected.spvasm index acde02b713..8940d6d772 100644 --- a/test/tint/bug/tint/403.wgsl.expected.spvasm +++ b/test/tint/bug/tint/403.wgsl.expected.spvasm @@ -70,8 +70,8 @@ %39 = OpConstantComposite %v2float %float_n1 %float_n1 %40 = OpConstantComposite %_arr_v2float_uint_3 %37 %38 %39 %_ptr_Function_v2float = OpTypePointer Function %v2float + %44 = OpConstantNull %uint %uint_1 = OpConstant %uint 1 - %float_0 = OpConstant %float 0 %void = OpTypeVoid %57 = OpTypeFunction %void %main_inner = OpFunction %v4float None %20 @@ -85,17 +85,17 @@ OpStore %indexable %40 %42 = OpAccessChain %_ptr_Function_v2float %indexable %gl_VertexIndex %43 = OpLoad %v2float %42 - %44 = OpCompositeExtract %v2float %32 0 - %45 = OpCompositeExtract %v2float %34 0 - %46 = OpFAdd %v2float %44 %45 - %48 = OpCompositeExtract %v2float %32 1 - %49 = OpCompositeExtract %v2float %34 1 - %50 = OpFAdd %v2float %48 %49 - %51 = OpCompositeConstruct %mat2v2float %46 %50 - %52 = OpMatrixTimesVector %v2float %51 %43 - %53 = OpCompositeExtract %float %52 0 - %54 = OpCompositeExtract %float %52 1 - %56 = OpCompositeConstruct %v4float %53 %54 %float_0 %float_1 + %45 = OpCompositeExtract %v2float %32 0 + %46 = OpCompositeExtract %v2float %34 0 + %47 = OpFAdd %v2float %45 %46 + %49 = OpCompositeExtract %v2float %32 1 + %50 = OpCompositeExtract %v2float %34 1 + %51 = OpFAdd %v2float %49 %50 + %52 = OpCompositeConstruct %mat2v2float %47 %51 + %53 = OpMatrixTimesVector %v2float %52 %43 + %54 = OpCompositeExtract %float %53 0 + %55 = OpCompositeExtract %float %53 1 + %56 = OpCompositeConstruct %v4float %54 %55 %11 %float_1 OpReturnValue %56 OpFunctionEnd %main = OpFunction %void None %57 diff --git a/test/tint/bug/tint/413.spvasm.expected.spvasm b/test/tint/bug/tint/413.spvasm.expected.spvasm index 1bab131c47..a918f6579a 100644 --- a/test/tint/bug/tint/413.spvasm.expected.spvasm +++ b/test/tint/bug/tint/413.spvasm.expected.spvasm @@ -31,8 +31,8 @@ %15 = OpConstantNull %v4uint %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 - %int_0 = OpConstant %int 0 - %21 = OpConstantComposite %v2int %int_0 %int_0 + %20 = OpConstantNull %v2int + %21 = OpConstantNull %int %uint_0 = OpConstant %uint 0 %_ptr_Function_uint = OpTypePointer Function %uint %int_1 = OpConstant %int 1 @@ -40,7 +40,7 @@ %11 = OpLabel %srcValue = OpVariable %_ptr_Function_v4uint Function %15 %17 = OpLoad %3 %Src - %16 = OpImageFetch %v4uint %17 %21 Lod %int_0 + %16 = OpImageFetch %v4uint %17 %20 Lod %21 OpStore %srcValue %16 %24 = OpAccessChain %_ptr_Function_uint %srcValue %uint_0 %25 = OpLoad %uint %24 @@ -50,7 +50,7 @@ OpStore %26 %29 %30 = OpLoad %v4uint %srcValue %32 = OpLoad %7 %Dst - OpImageWrite %32 %21 %30 + OpImageWrite %32 %20 %30 OpReturn OpFunctionEnd %main = OpFunction %void None %8 diff --git a/test/tint/bug/tint/453.wgsl.expected.spvasm b/test/tint/bug/tint/453.wgsl.expected.spvasm index 826d1d21b2..946633cefb 100644 --- a/test/tint/bug/tint/453.wgsl.expected.spvasm +++ b/test/tint/bug/tint/453.wgsl.expected.spvasm @@ -30,8 +30,8 @@ %15 = OpConstantNull %v4uint %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 - %int_0 = OpConstant %int 0 - %21 = OpConstantComposite %v2int %int_0 %int_0 + %20 = OpConstantNull %v2int + %21 = OpConstantNull %int %uint_0 = OpConstant %uint 0 %_ptr_Function_uint = OpTypePointer Function %uint %uint_1 = OpConstant %uint 1 @@ -39,7 +39,7 @@ %11 = OpLabel %srcValue = OpVariable %_ptr_Function_v4uint Function %15 %17 = OpLoad %3 %Src - %16 = OpImageFetch %v4uint %17 %21 Lod %int_0 + %16 = OpImageFetch %v4uint %17 %20 Lod %21 OpStore %srcValue %16 %24 = OpAccessChain %_ptr_Function_uint %srcValue %uint_0 %25 = OpLoad %uint %24 @@ -47,6 +47,6 @@ %28 = OpLoad %v4uint %srcValue %30 = OpLoad %7 %Dst %31 = OpVectorShuffle %v4uint %28 %28 0 0 0 0 - OpImageWrite %30 %21 %31 + OpImageWrite %30 %20 %31 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/534.wgsl.expected.spvasm b/test/tint/bug/tint/534.wgsl.expected.spvasm index 1a9da0ceca..98bd3e7986 100644 --- a/test/tint/bug/tint/534.wgsl.expected.spvasm +++ b/test/tint/bug/tint/534.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 137 +; Bound: 138 ; Schema: 0 OpCapability Shader OpCapability ImageQuery @@ -85,20 +85,21 @@ %_ptr_Function_int = OpTypePointer Function %int %int_1 = OpConstant %int 1 %v4float = OpTypeVector %float 4 + %62 = OpConstantNull %int %_ptr_Function_v4float = OpTypePointer Function %v4float - %64 = OpConstantNull %v4float + %65 = OpConstantNull %v4float %true = OpConstantTrue %bool %_ptr_Function_bool = OpTypePointer Function %bool - %72 = OpConstantNull %bool + %73 = OpConstantNull %bool %v4uint = OpTypeVector %uint 4 %_ptr_Function_v4uint = OpTypePointer Function %v4uint - %76 = OpConstantNull %v4uint + %77 = OpConstantNull %v4uint + %81 = OpConstantNull %uint %_ptr_Function_uint = OpTypePointer Function %uint - %82 = OpConstantNull %uint %uint_3 = OpConstant %uint 3 %_ptr_Function_float = OpTypePointer Function %float %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint - %132 = OpTypeFunction %void + %133 = OpTypeFunction %void %ConvertToFp16FloatValue = OpFunction %uint None %17 %fp32 = OpFunctionParameter %float %20 = OpLabel @@ -110,13 +111,13 @@ %size = OpVariable %_ptr_Function_v2int Function %34 %dstTexCoord = OpVariable %_ptr_Function_v2int Function %34 %srcTexCoord = OpVariable %_ptr_Function_v2int Function %34 - %srcColor = OpVariable %_ptr_Function_v4float Function %64 - %dstColor = OpVariable %_ptr_Function_v4float Function %64 - %success = OpVariable %_ptr_Function_bool Function %72 -%srcColorBits = OpVariable %_ptr_Function_v4uint Function %76 -%dstColorBits = OpVariable %_ptr_Function_v4uint Function %76 - %i = OpVariable %_ptr_Function_uint Function %82 -%outputIndex = OpVariable %_ptr_Function_uint Function %82 + %srcColor = OpVariable %_ptr_Function_v4float Function %65 + %dstColor = OpVariable %_ptr_Function_v4float Function %65 + %success = OpVariable %_ptr_Function_bool Function %73 +%srcColorBits = OpVariable %_ptr_Function_v4uint Function %77 +%dstColorBits = OpVariable %_ptr_Function_v4uint Function %77 + %i = OpVariable %_ptr_Function_uint Function %81 +%outputIndex = OpVariable %_ptr_Function_uint Function %81 %30 = OpLoad %7 %src %27 = OpImageQuerySizeLod %v2int %30 %int_0 OpStore %size %27 @@ -143,88 +144,88 @@ %47 = OpLabel %60 = OpLoad %7 %src %61 = OpLoad %v2int %srcTexCoord - %58 = OpImageFetch %v4float %60 %61 Lod %int_0 + %58 = OpImageFetch %v4float %60 %61 Lod %62 OpStore %srcColor %58 - %66 = OpLoad %7 %dst - %67 = OpLoad %v2int %dstTexCoord - %65 = OpImageFetch %v4float %66 %67 Lod %int_0 - OpStore %dstColor %65 + %67 = OpLoad %7 %dst + %68 = OpLoad %v2int %dstTexCoord + %66 = OpImageFetch %v4float %67 %68 Lod %62 + OpStore %dstColor %66 OpStore %success %true - %78 = OpLoad %v4float %dstColor - %77 = OpConvertFToU %v4uint %78 - OpStore %dstColorBits %77 - OpStore %i %uint_0 - OpBranch %83 - %83 = OpLabel - OpLoopMerge %84 %85 None + %79 = OpLoad %v4float %dstColor + %78 = OpConvertFToU %v4uint %79 + OpStore %dstColorBits %78 + OpStore %i %81 + OpBranch %84 + %84 = OpLabel + OpLoopMerge %85 %86 None + OpBranch %87 + %87 = OpLabel + %89 = OpLoad %uint %i + %91 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_3 + %92 = OpLoad %uint %91 + %93 = OpULessThan %bool %89 %92 + %88 = OpLogicalNot %bool %93 + OpSelectionMerge %94 None + OpBranchConditional %88 %95 %94 + %95 = OpLabel + OpBranch %85 + %94 = OpLabel + %97 = OpLoad %uint %i + %99 = OpAccessChain %_ptr_Function_float %srcColor %97 + %100 = OpLoad %float %99 + %96 = OpFunctionCall %uint %ConvertToFp16FloatValue %100 + %101 = OpLoad %uint %i + %102 = OpAccessChain %_ptr_Function_uint %srcColorBits %101 + OpStore %102 %96 + %103 = OpLoad %bool %success + OpSelectionMerge %104 None + OpBranchConditional %103 %105 %104 + %105 = OpLabel + %106 = OpLoad %uint %i + %107 = OpAccessChain %_ptr_Function_uint %srcColorBits %106 + %108 = OpLoad %uint %107 + %109 = OpLoad %uint %i + %110 = OpAccessChain %_ptr_Function_uint %dstColorBits %109 + %111 = OpLoad %uint %110 + %112 = OpIEqual %bool %108 %111 + OpBranch %104 + %104 = OpLabel + %113 = OpPhi %bool %103 %94 %112 %105 + OpStore %success %113 OpBranch %86 %86 = OpLabel - %88 = OpLoad %uint %i - %90 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_3 - %91 = OpLoad %uint %90 - %92 = OpULessThan %bool %88 %91 - %87 = OpLogicalNot %bool %92 - OpSelectionMerge %93 None - OpBranchConditional %87 %94 %93 - %94 = OpLabel + %114 = OpLoad %uint %i + %115 = OpIAdd %uint %114 %uint_1 + OpStore %i %115 OpBranch %84 - %93 = OpLabel - %96 = OpLoad %uint %i - %98 = OpAccessChain %_ptr_Function_float %srcColor %96 - %99 = OpLoad %float %98 - %95 = OpFunctionCall %uint %ConvertToFp16FloatValue %99 - %100 = OpLoad %uint %i - %101 = OpAccessChain %_ptr_Function_uint %srcColorBits %100 - OpStore %101 %95 - %102 = OpLoad %bool %success - OpSelectionMerge %103 None - OpBranchConditional %102 %104 %103 - %104 = OpLabel - %105 = OpLoad %uint %i - %106 = OpAccessChain %_ptr_Function_uint %srcColorBits %105 - %107 = OpLoad %uint %106 - %108 = OpLoad %uint %i - %109 = OpAccessChain %_ptr_Function_uint %dstColorBits %108 - %110 = OpLoad %uint %109 - %111 = OpIEqual %bool %107 %110 - OpBranch %103 - %103 = OpLabel - %112 = OpPhi %bool %102 %93 %111 %104 - OpStore %success %112 - OpBranch %85 %85 = OpLabel - %113 = OpLoad %uint %i - %114 = OpIAdd %uint %113 %uint_1 - OpStore %i %114 - OpBranch %83 - %84 = OpLabel - %115 = OpCompositeExtract %uint %GlobalInvocationID 1 - %117 = OpAccessChain %_ptr_Function_int %size %uint_0 - %118 = OpLoad %int %117 - %116 = OpBitcast %uint %118 - %119 = OpIMul %uint %115 %116 - %120 = OpCompositeExtract %uint %GlobalInvocationID 0 - %121 = OpIAdd %uint %119 %120 - OpStore %outputIndex %121 - %123 = OpLoad %bool %success - OpSelectionMerge %124 None - OpBranchConditional %123 %125 %126 - %125 = OpLabel - %127 = OpLoad %uint %outputIndex - %129 = OpAccessChain %_ptr_StorageBuffer_uint %output %uint_0 %127 - OpStore %129 %uint_1 - OpBranch %124 + %116 = OpCompositeExtract %uint %GlobalInvocationID 1 + %118 = OpAccessChain %_ptr_Function_int %size %uint_0 + %119 = OpLoad %int %118 + %117 = OpBitcast %uint %119 + %120 = OpIMul %uint %116 %117 + %121 = OpCompositeExtract %uint %GlobalInvocationID 0 + %122 = OpIAdd %uint %120 %121 + OpStore %outputIndex %122 + %124 = OpLoad %bool %success + OpSelectionMerge %125 None + OpBranchConditional %124 %126 %127 %126 = OpLabel - %130 = OpLoad %uint %outputIndex - %131 = OpAccessChain %_ptr_StorageBuffer_uint %output %uint_0 %130 - OpStore %131 %uint_0 - OpBranch %124 - %124 = OpLabel + %128 = OpLoad %uint %outputIndex + %130 = OpAccessChain %_ptr_StorageBuffer_uint %output %uint_0 %128 + OpStore %130 %uint_1 + OpBranch %125 + %127 = OpLabel + %131 = OpLoad %uint %outputIndex + %132 = OpAccessChain %_ptr_StorageBuffer_uint %output %uint_0 %131 + OpStore %132 %81 + OpBranch %125 + %125 = OpLabel OpReturn OpFunctionEnd - %main = OpFunction %void None %132 - %134 = OpLabel - %136 = OpLoad %v3uint %GlobalInvocationID_1 - %135 = OpFunctionCall %void %main_inner %136 + %main = OpFunction %void None %133 + %135 = OpLabel + %137 = OpLoad %v3uint %GlobalInvocationID_1 + %136 = OpFunctionCall %void %main_inner %137 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/744.wgsl.expected.spvasm b/test/tint/bug/tint/744.wgsl.expected.spvasm index 33d57e0a32..2bc71b48d9 100644 --- a/test/tint/bug/tint/744.wgsl.expected.spvasm +++ b/test/tint/bug/tint/744.wgsl.expected.spvasm @@ -63,16 +63,16 @@ %uint_1 = OpConstant %uint 1 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %uint_2 = OpConstant %uint 2 + %31 = OpConstantNull %uint %_ptr_Function_uint = OpTypePointer Function %uint - %33 = OpConstantNull %uint %bool = OpTypeBool %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint %69 = OpTypeFunction %void %main_inner = OpFunction %void None %15 %global_id = OpFunctionParameter %v3uint %19 = OpLabel - %result = OpVariable %_ptr_Function_uint Function %33 - %i = OpVariable %_ptr_Function_uint Function %33 + %result = OpVariable %_ptr_Function_uint Function %31 + %i = OpVariable %_ptr_Function_uint Function %31 %20 = OpCompositeExtract %uint %global_id 1 %21 = OpCompositeExtract %uint %global_id 0 %22 = OpCompositeConstruct %v2uint %20 %21 @@ -80,8 +80,8 @@ %27 = OpLoad %uint %26 %29 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_2 %uint_1 %30 = OpLoad %uint %29 - OpStore %result %uint_0 - OpStore %i %uint_0 + OpStore %result %31 + OpStore %i %31 OpBranch %35 %35 = OpLabel OpLoopMerge %36 %37 None diff --git a/test/tint/bug/tint/749.spvasm.expected.spvasm b/test/tint/bug/tint/749.spvasm.expected.spvasm index 5f5c422d9f..6843c302e2 100644 --- a/test/tint/bug/tint/749.spvasm.expected.spvasm +++ b/test/tint/bug/tint/749.spvasm.expected.spvasm @@ -1,10 +1,10 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 1833 +; Bound: 1831 ; Schema: 0 OpCapability Shader - %1694 = OpExtInstImport "GLSL.std.450" + %1692 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %gl_FragCoord_param_1 %x_GLF_color_1_1 OpExecutionMode %main OriginUpperLeft @@ -87,36 +87,34 @@ %_ptr_Function_int = OpTypePointer Function %int %23 = OpTypeFunction %void %_ptr_Function_int %_ptr_Function_int %31 = OpConstantNull %int - %int_0 = OpConstant %int 0 %v3float = OpTypeVector %float 3 %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %float_3 = OpConstant %float 3 - %38 = OpConstantComposite %v3float %float_1 %float_2 %float_3 + %37 = OpConstantComposite %v3float %float_1 %float_2 %float_3 %uint_0 = OpConstant %uint 0 %_ptr_Private_int = OpTypePointer Private %int - %102 = OpConstantComposite %_arr_int_uint_10 %int_0 %int_0 %int_0 %int_0 %int_0 %int_0 %int_0 %int_0 %int_0 %int_0 - %103 = OpConstantComposite %QuicksortObject %102 - %154 = OpTypeFunction %int %_ptr_Function_int %_ptr_Function_int + %101 = OpConstantComposite %_arr_int_uint_10 %31 %31 %31 %31 %31 %31 %31 %31 %31 %31 + %102 = OpConstantComposite %QuicksortObject %101 + %153 = OpTypeFunction %int %_ptr_Function_int %_ptr_Function_int %_ptr_Function_v2float = OpTypePointer Function %v2float - %168 = OpConstantNull %v2float + %167 = OpConstantNull %v2float %_ptr_Function_v3float = OpTypePointer Function %v3float - %171 = OpConstantNull %v3float + %170 = OpConstantNull %v3float %uint_1 = OpConstant %uint 1 %int_10 = OpConstant %int 10 %_ptr_Function_float = OpTypePointer Function %float %bool = OpTypeBool %int_1 = OpConstant %int 1 - %419 = OpTypeFunction %void + %418 = OpTypeFunction %void %_ptr_Function__arr_int_uint_10 = OpTypePointer Function %_arr_int_uint_10 - %429 = OpConstantNull %_arr_int_uint_10 + %428 = OpConstantNull %_arr_int_uint_10 %int_9 = OpConstant %int 9 %int_n1 = OpConstant %int -1 - %float_0 = OpConstant %float 0 - %876 = OpConstantComposite %v2float %float_0 %float_0 + %521 = OpConstantNull %uint %true = OpConstantTrue %bool - %888 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float + %950 = OpConstantNull %float %float_0_25 = OpConstant %float 0.25 %float_0_5 = OpConstant %float 0.5 %uint_2 = OpConstant %uint 2 @@ -129,148 +127,148 @@ %int_8 = OpConstant %int 8 %uint_9 = OpConstant %uint 9 %main_out = OpTypeStruct %v4float - %1820 = OpTypeFunction %main_out %v4float + %1818 = OpTypeFunction %main_out %v4float %swap_i1_i1_ = OpFunction %void None %23 %i = OpFunctionParameter %_ptr_Function_int %j = OpFunctionParameter %_ptr_Function_int %29 = OpLabel %temp = OpVariable %_ptr_Function_int Function %31 %32 = OpLoad %int %temp - OpStore %temp %int_0 + OpStore %temp %31 OpStore %temp %32 - %39 = OpCompositeExtract %float %38 2 - %40 = OpCompositeExtract %float %38 1 - %41 = OpCompositeExtract %float %38 2 - %42 = OpCompositeConstruct %v3float %39 %40 %41 - %44 = OpLoad %int %i - OpStore %i %int_0 - OpStore %i %44 - %48 = OpLoad %int %i - %50 = OpLoad %int %j - OpStore %j %int_0 - OpStore %j %50 - %53 = OpCompositeExtract %float %42 1 - %54 = OpCompositeExtract %float %42 0 - %55 = OpCompositeExtract %float %42 1 - %56 = OpCompositeConstruct %v3float %53 %54 %55 - %57 = OpLoad %int %temp - OpStore %temp %int_0 - OpStore %temp %57 - %60 = OpAccessChain %_ptr_Private_int %obj %uint_0 %48 - %61 = OpLoad %int %60 - %62 = OpAccessChain %_ptr_Private_int %obj %uint_0 %48 - OpStore %62 %int_0 - %63 = OpAccessChain %_ptr_Private_int %obj %uint_0 %48 - OpStore %63 %61 - %64 = OpAccessChain %_ptr_Private_int %obj %uint_0 %48 - %65 = OpLoad %int %64 - %66 = OpLoad %int %temp - OpStore %temp %int_0 - OpStore %temp %66 + %38 = OpCompositeExtract %float %37 2 + %39 = OpCompositeExtract %float %37 1 + %40 = OpCompositeExtract %float %37 2 + %41 = OpCompositeConstruct %v3float %38 %39 %40 + %43 = OpLoad %int %i + OpStore %i %31 + OpStore %i %43 + %47 = OpLoad %int %i + %49 = OpLoad %int %j + OpStore %j %31 + OpStore %j %49 + %52 = OpCompositeExtract %float %41 1 + %53 = OpCompositeExtract %float %41 0 + %54 = OpCompositeExtract %float %41 1 + %55 = OpCompositeConstruct %v3float %52 %53 %54 + %56 = OpLoad %int %temp + OpStore %temp %31 + OpStore %temp %56 + %59 = OpAccessChain %_ptr_Private_int %obj %uint_0 %47 + %60 = OpLoad %int %59 + %61 = OpAccessChain %_ptr_Private_int %obj %uint_0 %47 + OpStore %61 %31 + %62 = OpAccessChain %_ptr_Private_int %obj %uint_0 %47 + OpStore %62 %60 + %63 = OpAccessChain %_ptr_Private_int %obj %uint_0 %47 + %64 = OpLoad %int %63 + %65 = OpLoad %int %temp + OpStore %temp %31 OpStore %temp %65 - %68 = OpLoad %int %j - OpStore %j %int_0 - OpStore %j %68 - %71 = OpCompositeExtract %float %42 2 - %72 = OpCompositeExtract %float %38 0 - %73 = OpCompositeExtract %float %42 1 - %74 = OpCompositeConstruct %v3float %71 %72 %73 - %76 = OpLoad %int %i - OpStore %i %int_0 - OpStore %i %76 - %80 = OpLoad %int %i - %81 = OpAccessChain %_ptr_Private_int %obj %uint_0 %48 - %82 = OpLoad %int %81 - %83 = OpAccessChain %_ptr_Private_int %obj %uint_0 %48 - OpStore %83 %int_0 - %84 = OpAccessChain %_ptr_Private_int %obj %uint_0 %48 - OpStore %84 %82 - %86 = OpLoad %int %j - %88 = OpLoad %int %i - OpStore %i %int_0 - OpStore %i %88 - %91 = OpCompositeExtract %float %74 0 - %92 = OpCompositeExtract %float %74 2 - %93 = OpCompositeExtract %float %74 2 - %94 = OpCompositeConstruct %v3float %91 %92 %93 - %95 = OpAccessChain %_ptr_Private_int %obj %uint_0 %48 - %96 = OpLoad %int %95 - %97 = OpAccessChain %_ptr_Private_int %obj %uint_0 %48 - OpStore %97 %int_0 - %98 = OpAccessChain %_ptr_Private_int %obj %uint_0 %48 - OpStore %98 %96 - %99 = OpAccessChain %_ptr_Private_int %obj %uint_0 %86 - %100 = OpLoad %int %99 - %101 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %101 - %104 = OpCompositeExtract %float %94 0 - %105 = OpCompositeExtract %float %94 0 - %106 = OpCompositeConstruct %v2float %104 %105 - %107 = OpCompositeExtract %float %56 0 - %108 = OpCompositeExtract %float %56 2 - %109 = OpCompositeExtract %float %56 0 - %110 = OpCompositeConstruct %v3float %107 %108 %109 - %111 = OpAccessChain %_ptr_Private_int %obj %uint_0 %80 - OpStore %111 %100 - %112 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %112 - %113 = OpCompositeExtract %float %94 1 - %114 = OpCompositeExtract %float %94 2 - %115 = OpCompositeExtract %float %94 0 - %116 = OpCompositeConstruct %v3float %113 %114 %115 - %118 = OpLoad %int %i - OpStore %i %int_0 - OpStore %i %118 - %122 = OpLoad %int %j - %123 = OpLoad %int %temp - OpStore %temp %int_0 - OpStore %temp %123 - %124 = OpCompositeExtract %float %116 2 - %125 = OpCompositeExtract %float %116 1 - %126 = OpCompositeConstruct %v2float %124 %125 - %127 = OpAccessChain %_ptr_Private_int %obj %uint_0 %86 - %128 = OpLoad %int %127 - %129 = OpAccessChain %_ptr_Private_int %obj %uint_0 %86 - OpStore %129 %int_0 - %130 = OpAccessChain %_ptr_Private_int %obj %uint_0 %86 - OpStore %130 %128 - %131 = OpLoad %int %temp - %133 = OpLoad %int %j - OpStore %j %int_0 - OpStore %j %133 - %136 = OpCompositeExtract %float %106 0 - %137 = OpCompositeExtract %float %94 1 - %138 = OpCompositeExtract %float %94 0 - %139 = OpCompositeConstruct %v3float %136 %137 %138 - %140 = OpAccessChain %_ptr_Private_int %obj %uint_0 %80 - %141 = OpLoad %int %140 - %142 = OpAccessChain %_ptr_Private_int %obj %uint_0 %80 - OpStore %142 %int_0 - %143 = OpAccessChain %_ptr_Private_int %obj %uint_0 %80 - OpStore %143 %141 - %144 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %144 - %145 = OpCompositeExtract %float %110 0 - %146 = OpCompositeExtract %float %110 1 - %147 = OpCompositeExtract %float %110 0 - %148 = OpCompositeConstruct %v3float %145 %146 %147 - %149 = OpAccessChain %_ptr_Private_int %obj %uint_0 %86 - %150 = OpLoad %int %149 - %151 = OpAccessChain %_ptr_Private_int %obj %uint_0 %86 - OpStore %151 %int_0 - %152 = OpAccessChain %_ptr_Private_int %obj %uint_0 %86 - OpStore %152 %150 - %153 = OpAccessChain %_ptr_Private_int %obj %uint_0 %122 - OpStore %153 %131 + OpStore %temp %64 + %67 = OpLoad %int %j + OpStore %j %31 + OpStore %j %67 + %70 = OpCompositeExtract %float %41 2 + %71 = OpCompositeExtract %float %37 0 + %72 = OpCompositeExtract %float %41 1 + %73 = OpCompositeConstruct %v3float %70 %71 %72 + %75 = OpLoad %int %i + OpStore %i %31 + OpStore %i %75 + %79 = OpLoad %int %i + %80 = OpAccessChain %_ptr_Private_int %obj %uint_0 %47 + %81 = OpLoad %int %80 + %82 = OpAccessChain %_ptr_Private_int %obj %uint_0 %47 + OpStore %82 %31 + %83 = OpAccessChain %_ptr_Private_int %obj %uint_0 %47 + OpStore %83 %81 + %85 = OpLoad %int %j + %87 = OpLoad %int %i + OpStore %i %31 + OpStore %i %87 + %90 = OpCompositeExtract %float %73 0 + %91 = OpCompositeExtract %float %73 2 + %92 = OpCompositeExtract %float %73 2 + %93 = OpCompositeConstruct %v3float %90 %91 %92 + %94 = OpAccessChain %_ptr_Private_int %obj %uint_0 %47 + %95 = OpLoad %int %94 + %96 = OpAccessChain %_ptr_Private_int %obj %uint_0 %47 + OpStore %96 %31 + %97 = OpAccessChain %_ptr_Private_int %obj %uint_0 %47 + OpStore %97 %95 + %98 = OpAccessChain %_ptr_Private_int %obj %uint_0 %85 + %99 = OpLoad %int %98 + %100 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %100 + %103 = OpCompositeExtract %float %93 0 + %104 = OpCompositeExtract %float %93 0 + %105 = OpCompositeConstruct %v2float %103 %104 + %106 = OpCompositeExtract %float %55 0 + %107 = OpCompositeExtract %float %55 2 + %108 = OpCompositeExtract %float %55 0 + %109 = OpCompositeConstruct %v3float %106 %107 %108 + %110 = OpAccessChain %_ptr_Private_int %obj %uint_0 %79 + OpStore %110 %99 + %111 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %111 + %112 = OpCompositeExtract %float %93 1 + %113 = OpCompositeExtract %float %93 2 + %114 = OpCompositeExtract %float %93 0 + %115 = OpCompositeConstruct %v3float %112 %113 %114 + %117 = OpLoad %int %i + OpStore %i %31 + OpStore %i %117 + %121 = OpLoad %int %j + %122 = OpLoad %int %temp + OpStore %temp %31 + OpStore %temp %122 + %123 = OpCompositeExtract %float %115 2 + %124 = OpCompositeExtract %float %115 1 + %125 = OpCompositeConstruct %v2float %123 %124 + %126 = OpAccessChain %_ptr_Private_int %obj %uint_0 %85 + %127 = OpLoad %int %126 + %128 = OpAccessChain %_ptr_Private_int %obj %uint_0 %85 + OpStore %128 %31 + %129 = OpAccessChain %_ptr_Private_int %obj %uint_0 %85 + OpStore %129 %127 + %130 = OpLoad %int %temp + %132 = OpLoad %int %j + OpStore %j %31 + OpStore %j %132 + %135 = OpCompositeExtract %float %105 0 + %136 = OpCompositeExtract %float %93 1 + %137 = OpCompositeExtract %float %93 0 + %138 = OpCompositeConstruct %v3float %135 %136 %137 + %139 = OpAccessChain %_ptr_Private_int %obj %uint_0 %79 + %140 = OpLoad %int %139 + %141 = OpAccessChain %_ptr_Private_int %obj %uint_0 %79 + OpStore %141 %31 + %142 = OpAccessChain %_ptr_Private_int %obj %uint_0 %79 + OpStore %142 %140 + %143 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %143 + %144 = OpCompositeExtract %float %109 0 + %145 = OpCompositeExtract %float %109 1 + %146 = OpCompositeExtract %float %109 0 + %147 = OpCompositeConstruct %v3float %144 %145 %146 + %148 = OpAccessChain %_ptr_Private_int %obj %uint_0 %85 + %149 = OpLoad %int %148 + %150 = OpAccessChain %_ptr_Private_int %obj %uint_0 %85 + OpStore %150 %31 + %151 = OpAccessChain %_ptr_Private_int %obj %uint_0 %85 + OpStore %151 %149 + %152 = OpAccessChain %_ptr_Private_int %obj %uint_0 %121 + OpStore %152 %130 OpReturn OpFunctionEnd -%performPartition_i1_i1_ = OpFunction %int None %154 +%performPartition_i1_i1_ = OpFunction %int None %153 %l = OpFunctionParameter %_ptr_Function_int %h = OpFunctionParameter %_ptr_Function_int - %158 = OpLabel + %157 = OpLabel %param_3 = OpVariable %_ptr_Function_int Function %31 %i_1 = OpVariable %_ptr_Function_int Function %31 %j_1 = OpVariable %_ptr_Function_int Function %31 @@ -278,671 +276,671 @@ %param_1 = OpVariable %_ptr_Function_int Function %31 %param = OpVariable %_ptr_Function_int Function %31 %pivot = OpVariable %_ptr_Function_int Function %31 - %x_537 = OpVariable %_ptr_Function_v2float Function %168 - %x_538 = OpVariable %_ptr_Function_v3float Function %171 - %173 = OpLoad %int %h - OpStore %h %int_0 - OpStore %h %173 - %177 = OpLoad %int %h - %179 = OpLoad %int %l - OpStore %l %int_0 - OpStore %l %179 - %182 = OpAccessChain %_ptr_Private_int %obj %uint_0 %177 - %183 = OpLoad %int %182 - %184 = OpAccessChain %_ptr_Private_int %obj %uint_0 %177 - OpStore %184 %int_0 - %185 = OpAccessChain %_ptr_Private_int %obj %uint_0 %177 - OpStore %185 %183 - %186 = OpAccessChain %_ptr_Private_int %obj %uint_0 %177 - %187 = OpLoad %int %186 - %188 = OpLoad %int %param_3 - OpStore %param_3 %int_0 - OpStore %param_3 %188 - %189 = OpCompositeExtract %float %38 2 - %190 = OpCompositeExtract %float %38 0 - %191 = OpCompositeExtract %float %38 2 - %192 = OpCompositeConstruct %v3float %189 %190 %191 - %193 = OpLoad %int %param_1 - OpStore %param_1 %int_0 - OpStore %param_1 %193 - OpStore %pivot %187 - %195 = OpLoad %int %l - %197 = OpLoad %int %h - OpStore %h %int_0 - OpStore %h %197 - %200 = OpLoad %int %j_1 - OpStore %j_1 %int_0 - OpStore %j_1 %200 - %201 = OpCompositeExtract %float %192 1 - %202 = OpCompositeExtract %float %192 2 - %203 = OpCompositeExtract %float %192 1 - %204 = OpCompositeConstruct %v3float %201 %202 %203 - %206 = OpLoad %int %l - OpStore %l %int_0 - OpStore %l %206 - %209 = OpBitcast %int %uint_1 - %211 = OpISub %int %195 %209 - OpStore %i_1 %211 - %213 = OpLoad %int %l - %214 = OpCompositeExtract %float %192 0 - %215 = OpCompositeExtract %float %192 2 - %216 = OpCompositeExtract %float %204 0 - %217 = OpCompositeConstruct %v3float %214 %215 %216 + %x_537 = OpVariable %_ptr_Function_v2float Function %167 + %x_538 = OpVariable %_ptr_Function_v3float Function %170 + %172 = OpLoad %int %h + OpStore %h %31 + OpStore %h %172 + %176 = OpLoad %int %h + %178 = OpLoad %int %l + OpStore %l %31 + OpStore %l %178 + %181 = OpAccessChain %_ptr_Private_int %obj %uint_0 %176 + %182 = OpLoad %int %181 + %183 = OpAccessChain %_ptr_Private_int %obj %uint_0 %176 + OpStore %183 %31 + %184 = OpAccessChain %_ptr_Private_int %obj %uint_0 %176 + OpStore %184 %182 + %185 = OpAccessChain %_ptr_Private_int %obj %uint_0 %176 + %186 = OpLoad %int %185 + %187 = OpLoad %int %param_3 + OpStore %param_3 %31 + OpStore %param_3 %187 + %188 = OpCompositeExtract %float %37 2 + %189 = OpCompositeExtract %float %37 0 + %190 = OpCompositeExtract %float %37 2 + %191 = OpCompositeConstruct %v3float %188 %189 %190 + %192 = OpLoad %int %param_1 + OpStore %param_1 %31 + OpStore %param_1 %192 + OpStore %pivot %186 + %194 = OpLoad %int %l + %196 = OpLoad %int %h + OpStore %h %31 + OpStore %h %196 + %199 = OpLoad %int %j_1 + OpStore %j_1 %31 + OpStore %j_1 %199 + %200 = OpCompositeExtract %float %191 1 + %201 = OpCompositeExtract %float %191 2 + %202 = OpCompositeExtract %float %191 1 + %203 = OpCompositeConstruct %v3float %200 %201 %202 + %205 = OpLoad %int %l + OpStore %l %31 + OpStore %l %205 + %208 = OpBitcast %int %uint_1 + %210 = OpISub %int %194 %208 + OpStore %i_1 %210 + %212 = OpLoad %int %l + %213 = OpCompositeExtract %float %191 0 + %214 = OpCompositeExtract %float %191 2 + %215 = OpCompositeExtract %float %203 0 + %216 = OpCompositeConstruct %v3float %213 %214 %215 OpStore %j_1 %int_10 - %219 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %219 - OpBranch %220 - %220 = OpLabel - OpLoopMerge %221 %222 None - OpBranch %223 - %223 = OpLabel - %224 = OpLoad %int %pivot - OpStore %pivot %int_0 - OpStore %pivot %224 - %225 = OpLoad %int %param_1 - OpStore %param_1 %int_0 - OpStore %param_1 %225 - %226 = OpLoad %int %j_1 - %227 = OpLoad %int %pivot - OpStore %pivot %int_0 - OpStore %pivot %227 - %228 = OpCompositeExtract %float %38 1 - %229 = OpCompositeExtract %float %38 2 - %230 = OpCompositeConstruct %v2float %228 %229 - OpStore %x_537 %230 - %231 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %231 - %233 = OpLoad %int %h - %235 = OpLoad %int %h - OpStore %h %int_0 - OpStore %h %235 - %238 = OpLoad %int %param - OpStore %param %int_0 - OpStore %param %238 - %239 = OpLoad %int %j_1 - OpStore %j_1 %int_0 - OpStore %j_1 %239 - %240 = OpCompositeExtract %float %192 0 - %242 = OpAccessChain %_ptr_Function_float %x_537 %uint_1 - %243 = OpLoad %float %242 - %244 = OpCompositeExtract %float %192 2 - %245 = OpCompositeConstruct %v3float %240 %243 %244 - OpStore %x_538 %245 - %246 = OpLoad %int %param - OpStore %param %int_0 - OpStore %param %246 - %247 = OpBitcast %int %uint_1 - %248 = OpISub %int %233 %247 - %249 = OpSLessThanEqual %bool %226 %248 - OpSelectionMerge %251 None - OpBranchConditional %249 %252 %253 - %252 = OpLabel - OpBranch %251 - %253 = OpLabel - OpBranch %221 - %251 = OpLabel - %254 = OpLoad %int %j_1 - %255 = OpAccessChain %_ptr_Private_int %obj %uint_0 %177 - %256 = OpLoad %int %255 - %257 = OpAccessChain %_ptr_Private_int %obj %uint_0 %177 - OpStore %257 %int_0 - %258 = OpAccessChain %_ptr_Private_int %obj %uint_0 %177 - OpStore %258 %256 - %260 = OpLoad %int %h - OpStore %h %int_0 - OpStore %h %260 - %263 = OpAccessChain %_ptr_Function_float %x_537 %uint_0 - %264 = OpLoad %float %263 - %265 = OpCompositeExtract %float %204 2 - %266 = OpAccessChain %_ptr_Function_float %x_537 %uint_0 - %267 = OpLoad %float %266 - %268 = OpCompositeConstruct %v3float %264 %265 %267 - %269 = OpLoad %int %param_1 - OpStore %param_1 %int_0 - OpStore %param_1 %269 - %270 = OpAccessChain %_ptr_Private_int %obj %uint_0 %254 - %271 = OpLoad %int %270 - %272 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %272 - %273 = OpLoad %int %pivot - %274 = OpCompositeExtract %float %38 1 - %275 = OpCompositeExtract %float %192 2 - %276 = OpCompositeConstruct %v2float %274 %275 - %277 = OpLoad %int %i_1 - OpStore %i_1 %int_0 - OpStore %i_1 %277 - %279 = OpLoad %int %l - OpStore %l %int_0 - OpStore %l %279 - %282 = OpCompositeExtract %float %192 1 - %283 = OpCompositeExtract %float %192 0 - %284 = OpCompositeExtract %float %192 1 - %285 = OpCompositeConstruct %v3float %282 %283 %284 - %286 = OpLoad %int %pivot - OpStore %pivot %int_0 - OpStore %pivot %286 - %287 = OpSLessThanEqual %bool %271 %273 - OpSelectionMerge %288 None - OpBranchConditional %287 %289 %288 - %289 = OpLabel - %290 = OpCompositeExtract %float %285 2 - %291 = OpCompositeExtract %float %285 0 - %292 = OpCompositeExtract %float %285 0 - %293 = OpCompositeConstruct %v3float %290 %291 %292 - %294 = OpLoad %int %param_3 - OpStore %param_3 %int_0 - OpStore %param_3 %294 - %295 = OpLoad %int %i_1 - %296 = OpLoad %int %pivot - OpStore %pivot %int_0 - OpStore %pivot %296 - %297 = OpCompositeExtract %float %268 0 - %298 = OpCompositeExtract %float %285 1 - %299 = OpCompositeConstruct %v2float %297 %298 - %300 = OpLoad %int %i_1 - OpStore %i_1 %int_0 - OpStore %i_1 %300 - %301 = OpLoad %int %param - OpStore %param %int_0 - OpStore %param %301 - %302 = OpBitcast %int %uint_1 - %303 = OpIAdd %int %295 %302 - OpStore %i_1 %303 - %305 = OpLoad %int %l - OpStore %l %int_0 - OpStore %l %305 - %308 = OpCompositeExtract %float %38 2 - %309 = OpCompositeExtract %float %38 1 - %310 = OpCompositeExtract %float %276 0 - %311 = OpCompositeConstruct %v3float %308 %309 %310 - %312 = OpLoad %int %i_1 - %313 = OpAccessChain %_ptr_Function_float %x_537 %uint_1 - %314 = OpLoad %float %313 - %315 = OpAccessChain %_ptr_Function_float %x_538 %uint_0 - %316 = OpLoad %float %315 - %317 = OpCompositeConstruct %v2float %314 %316 - %318 = OpLoad %int %param - OpStore %param %int_0 - OpStore %param %318 - OpStore %param %312 - %319 = OpLoad %int %param - OpStore %param %int_0 - OpStore %param %319 - %320 = OpCompositeExtract %float %317 0 - %321 = OpCompositeExtract %float %317 0 - %322 = OpCompositeConstruct %v2float %320 %321 - %323 = OpLoad %int %i_1 - OpStore %i_1 %int_0 - OpStore %i_1 %323 - %324 = OpLoad %int %j_1 - OpStore %param_1 %324 - %325 = OpLoad %int %param_3 - OpStore %param_3 %int_0 - OpStore %param_3 %325 - %326 = OpFunctionCall %void %swap_i1_i1_ %param %param_1 - %329 = OpLoad %int %param_1 - OpStore %param_1 %int_0 - OpStore %param_1 %329 - OpBranch %288 - %288 = OpLabel - %330 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %330 + %218 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %218 + OpBranch %219 + %219 = OpLabel + OpLoopMerge %220 %221 None OpBranch %222 %222 = OpLabel - %332 = OpLoad %int %h - OpStore %h %int_0 - OpStore %h %332 - %335 = OpLoad %int %j_1 - %337 = OpLoad %int %h - OpStore %h %int_0 - OpStore %h %337 - %340 = OpCompositeExtract %float %268 0 - %341 = OpCompositeExtract %float %285 2 - %342 = OpCompositeExtract %float %285 2 - %343 = OpCompositeConstruct %v3float %340 %341 %342 - %344 = OpAccessChain %_ptr_Private_int %obj %uint_0 %254 - %345 = OpLoad %int %344 - %346 = OpAccessChain %_ptr_Private_int %obj %uint_0 %254 - OpStore %346 %int_0 - %347 = OpAccessChain %_ptr_Private_int %obj %uint_0 %254 - OpStore %347 %345 - %348 = OpLoad %int %param - OpStore %param %int_0 - OpStore %param %348 - %350 = OpIAdd %int %int_1 %335 - OpStore %j_1 %350 - %351 = OpLoad %int %param_1 - OpStore %param_1 %int_0 - OpStore %param_1 %351 - %352 = OpCompositeExtract %float %285 1 - %353 = OpCompositeExtract %float %285 2 - %354 = OpCompositeExtract %float %285 0 - %355 = OpCompositeConstruct %v3float %352 %353 %354 - %356 = OpAccessChain %_ptr_Private_int %obj %uint_0 %254 - %357 = OpLoad %int %356 - %358 = OpAccessChain %_ptr_Private_int %obj %uint_0 %254 - OpStore %358 %int_0 - %359 = OpAccessChain %_ptr_Private_int %obj %uint_0 %254 - OpStore %359 %357 + %223 = OpLoad %int %pivot + OpStore %pivot %31 + OpStore %pivot %223 + %224 = OpLoad %int %param_1 + OpStore %param_1 %31 + OpStore %param_1 %224 + %225 = OpLoad %int %j_1 + %226 = OpLoad %int %pivot + OpStore %pivot %31 + OpStore %pivot %226 + %227 = OpCompositeExtract %float %37 1 + %228 = OpCompositeExtract %float %37 2 + %229 = OpCompositeConstruct %v2float %227 %228 + OpStore %x_537 %229 + %230 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %230 + %232 = OpLoad %int %h + %234 = OpLoad %int %h + OpStore %h %31 + OpStore %h %234 + %237 = OpLoad %int %param + OpStore %param %31 + OpStore %param %237 + %238 = OpLoad %int %j_1 + OpStore %j_1 %31 + OpStore %j_1 %238 + %239 = OpCompositeExtract %float %191 0 + %241 = OpAccessChain %_ptr_Function_float %x_537 %uint_1 + %242 = OpLoad %float %241 + %243 = OpCompositeExtract %float %191 2 + %244 = OpCompositeConstruct %v3float %239 %242 %243 + OpStore %x_538 %244 + %245 = OpLoad %int %param + OpStore %param %31 + OpStore %param %245 + %246 = OpBitcast %int %uint_1 + %247 = OpISub %int %232 %246 + %248 = OpSLessThanEqual %bool %225 %247 + OpSelectionMerge %250 None + OpBranchConditional %248 %251 %252 + %251 = OpLabel + OpBranch %250 + %252 = OpLabel OpBranch %220 + %250 = OpLabel + %253 = OpLoad %int %j_1 + %254 = OpAccessChain %_ptr_Private_int %obj %uint_0 %176 + %255 = OpLoad %int %254 + %256 = OpAccessChain %_ptr_Private_int %obj %uint_0 %176 + OpStore %256 %31 + %257 = OpAccessChain %_ptr_Private_int %obj %uint_0 %176 + OpStore %257 %255 + %259 = OpLoad %int %h + OpStore %h %31 + OpStore %h %259 + %262 = OpAccessChain %_ptr_Function_float %x_537 %uint_0 + %263 = OpLoad %float %262 + %264 = OpCompositeExtract %float %203 2 + %265 = OpAccessChain %_ptr_Function_float %x_537 %uint_0 + %266 = OpLoad %float %265 + %267 = OpCompositeConstruct %v3float %263 %264 %266 + %268 = OpLoad %int %param_1 + OpStore %param_1 %31 + OpStore %param_1 %268 + %269 = OpAccessChain %_ptr_Private_int %obj %uint_0 %253 + %270 = OpLoad %int %269 + %271 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %271 + %272 = OpLoad %int %pivot + %273 = OpCompositeExtract %float %37 1 + %274 = OpCompositeExtract %float %191 2 + %275 = OpCompositeConstruct %v2float %273 %274 + %276 = OpLoad %int %i_1 + OpStore %i_1 %31 + OpStore %i_1 %276 + %278 = OpLoad %int %l + OpStore %l %31 + OpStore %l %278 + %281 = OpCompositeExtract %float %191 1 + %282 = OpCompositeExtract %float %191 0 + %283 = OpCompositeExtract %float %191 1 + %284 = OpCompositeConstruct %v3float %281 %282 %283 + %285 = OpLoad %int %pivot + OpStore %pivot %31 + OpStore %pivot %285 + %286 = OpSLessThanEqual %bool %270 %272 + OpSelectionMerge %287 None + OpBranchConditional %286 %288 %287 + %288 = OpLabel + %289 = OpCompositeExtract %float %284 2 + %290 = OpCompositeExtract %float %284 0 + %291 = OpCompositeExtract %float %284 0 + %292 = OpCompositeConstruct %v3float %289 %290 %291 + %293 = OpLoad %int %param_3 + OpStore %param_3 %31 + OpStore %param_3 %293 + %294 = OpLoad %int %i_1 + %295 = OpLoad %int %pivot + OpStore %pivot %31 + OpStore %pivot %295 + %296 = OpCompositeExtract %float %267 0 + %297 = OpCompositeExtract %float %284 1 + %298 = OpCompositeConstruct %v2float %296 %297 + %299 = OpLoad %int %i_1 + OpStore %i_1 %31 + OpStore %i_1 %299 + %300 = OpLoad %int %param + OpStore %param %31 + OpStore %param %300 + %301 = OpBitcast %int %uint_1 + %302 = OpIAdd %int %294 %301 + OpStore %i_1 %302 + %304 = OpLoad %int %l + OpStore %l %31 + OpStore %l %304 + %307 = OpCompositeExtract %float %37 2 + %308 = OpCompositeExtract %float %37 1 + %309 = OpCompositeExtract %float %275 0 + %310 = OpCompositeConstruct %v3float %307 %308 %309 + %311 = OpLoad %int %i_1 + %312 = OpAccessChain %_ptr_Function_float %x_537 %uint_1 + %313 = OpLoad %float %312 + %314 = OpAccessChain %_ptr_Function_float %x_538 %uint_0 + %315 = OpLoad %float %314 + %316 = OpCompositeConstruct %v2float %313 %315 + %317 = OpLoad %int %param + OpStore %param %31 + OpStore %param %317 + OpStore %param %311 + %318 = OpLoad %int %param + OpStore %param %31 + OpStore %param %318 + %319 = OpCompositeExtract %float %316 0 + %320 = OpCompositeExtract %float %316 0 + %321 = OpCompositeConstruct %v2float %319 %320 + %322 = OpLoad %int %i_1 + OpStore %i_1 %31 + OpStore %i_1 %322 + %323 = OpLoad %int %j_1 + OpStore %param_1 %323 + %324 = OpLoad %int %param_3 + OpStore %param_3 %31 + OpStore %param_3 %324 + %325 = OpFunctionCall %void %swap_i1_i1_ %param %param_1 + %328 = OpLoad %int %param_1 + OpStore %param_1 %31 + OpStore %param_1 %328 + OpBranch %287 + %287 = OpLabel + %329 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %329 + OpBranch %221 %221 = OpLabel - %360 = OpLoad %int %i_1 - %361 = OpAccessChain %_ptr_Private_int %obj %uint_0 %177 - %362 = OpLoad %int %361 - %363 = OpAccessChain %_ptr_Private_int %obj %uint_0 %177 - OpStore %363 %int_0 - %364 = OpAccessChain %_ptr_Private_int %obj %uint_0 %177 - OpStore %364 %362 - %365 = OpCompositeExtract %float %192 0 - %366 = OpCompositeExtract %float %192 1 - %367 = OpCompositeConstruct %v2float %365 %366 - %368 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %368 - %370 = OpLoad %int %h - OpStore %h %int_0 - OpStore %h %370 - %373 = OpIAdd %int %int_1 %360 - OpStore %i_1 %373 - %374 = OpLoad %int %param_1 - OpStore %param_1 %int_0 - OpStore %param_1 %374 - %375 = OpLoad %int %i_1 - %376 = OpLoad %int %j_1 - OpStore %j_1 %int_0 - OpStore %j_1 %376 - %377 = OpCompositeExtract %float %192 0 - %378 = OpCompositeExtract %float %192 0 - %379 = OpCompositeConstruct %v2float %377 %378 - %380 = OpLoad %int %param_1 - OpStore %param_1 %int_0 - OpStore %param_1 %380 - OpStore %param_2 %375 - %381 = OpCompositeExtract %float %192 1 - %382 = OpCompositeExtract %float %217 0 - %383 = OpCompositeConstruct %v2float %381 %382 - %384 = OpLoad %int %pivot - OpStore %pivot %int_0 - OpStore %pivot %384 - %386 = OpLoad %int %h - %387 = OpCompositeExtract %float %379 0 - %388 = OpCompositeExtract %float %367 1 - %389 = OpCompositeConstruct %v2float %387 %388 - %391 = OpLoad %int %h - OpStore %h %int_0 - OpStore %h %391 - OpStore %param_3 %386 - %394 = OpLoad %int %i_1 - OpStore %i_1 %int_0 - OpStore %i_1 %394 - %395 = OpCompositeExtract %float %367 1 - %396 = OpCompositeExtract %float %389 0 - %397 = OpCompositeConstruct %v2float %395 %396 - %399 = OpLoad %int %h - OpStore %h %int_0 - OpStore %h %399 - %402 = OpFunctionCall %void %swap_i1_i1_ %param_2 %param_3 - %406 = OpLoad %int %l - OpStore %l %int_0 - OpStore %l %406 - %409 = OpCompositeExtract %float %217 2 - %410 = OpCompositeExtract %float %38 1 - %411 = OpCompositeConstruct %v2float %409 %410 - %412 = OpLoad %int %param_1 - OpStore %param_1 %int_0 - OpStore %param_1 %412 - %413 = OpLoad %int %i_1 - %414 = OpLoad %int %param - OpStore %param %int_0 - OpStore %param %414 - %415 = OpCompositeExtract %float %192 1 - %416 = OpCompositeExtract %float %192 0 - %417 = OpCompositeConstruct %v2float %415 %416 - %418 = OpLoad %int %j_1 - OpStore %j_1 %int_0 - OpStore %j_1 %418 - OpReturnValue %413 + %331 = OpLoad %int %h + OpStore %h %31 + OpStore %h %331 + %334 = OpLoad %int %j_1 + %336 = OpLoad %int %h + OpStore %h %31 + OpStore %h %336 + %339 = OpCompositeExtract %float %267 0 + %340 = OpCompositeExtract %float %284 2 + %341 = OpCompositeExtract %float %284 2 + %342 = OpCompositeConstruct %v3float %339 %340 %341 + %343 = OpAccessChain %_ptr_Private_int %obj %uint_0 %253 + %344 = OpLoad %int %343 + %345 = OpAccessChain %_ptr_Private_int %obj %uint_0 %253 + OpStore %345 %31 + %346 = OpAccessChain %_ptr_Private_int %obj %uint_0 %253 + OpStore %346 %344 + %347 = OpLoad %int %param + OpStore %param %31 + OpStore %param %347 + %349 = OpIAdd %int %int_1 %334 + OpStore %j_1 %349 + %350 = OpLoad %int %param_1 + OpStore %param_1 %31 + OpStore %param_1 %350 + %351 = OpCompositeExtract %float %284 1 + %352 = OpCompositeExtract %float %284 2 + %353 = OpCompositeExtract %float %284 0 + %354 = OpCompositeConstruct %v3float %351 %352 %353 + %355 = OpAccessChain %_ptr_Private_int %obj %uint_0 %253 + %356 = OpLoad %int %355 + %357 = OpAccessChain %_ptr_Private_int %obj %uint_0 %253 + OpStore %357 %31 + %358 = OpAccessChain %_ptr_Private_int %obj %uint_0 %253 + OpStore %358 %356 + OpBranch %219 + %220 = OpLabel + %359 = OpLoad %int %i_1 + %360 = OpAccessChain %_ptr_Private_int %obj %uint_0 %176 + %361 = OpLoad %int %360 + %362 = OpAccessChain %_ptr_Private_int %obj %uint_0 %176 + OpStore %362 %31 + %363 = OpAccessChain %_ptr_Private_int %obj %uint_0 %176 + OpStore %363 %361 + %364 = OpCompositeExtract %float %191 0 + %365 = OpCompositeExtract %float %191 1 + %366 = OpCompositeConstruct %v2float %364 %365 + %367 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %367 + %369 = OpLoad %int %h + OpStore %h %31 + OpStore %h %369 + %372 = OpIAdd %int %int_1 %359 + OpStore %i_1 %372 + %373 = OpLoad %int %param_1 + OpStore %param_1 %31 + OpStore %param_1 %373 + %374 = OpLoad %int %i_1 + %375 = OpLoad %int %j_1 + OpStore %j_1 %31 + OpStore %j_1 %375 + %376 = OpCompositeExtract %float %191 0 + %377 = OpCompositeExtract %float %191 0 + %378 = OpCompositeConstruct %v2float %376 %377 + %379 = OpLoad %int %param_1 + OpStore %param_1 %31 + OpStore %param_1 %379 + OpStore %param_2 %374 + %380 = OpCompositeExtract %float %191 1 + %381 = OpCompositeExtract %float %216 0 + %382 = OpCompositeConstruct %v2float %380 %381 + %383 = OpLoad %int %pivot + OpStore %pivot %31 + OpStore %pivot %383 + %385 = OpLoad %int %h + %386 = OpCompositeExtract %float %378 0 + %387 = OpCompositeExtract %float %366 1 + %388 = OpCompositeConstruct %v2float %386 %387 + %390 = OpLoad %int %h + OpStore %h %31 + OpStore %h %390 + OpStore %param_3 %385 + %393 = OpLoad %int %i_1 + OpStore %i_1 %31 + OpStore %i_1 %393 + %394 = OpCompositeExtract %float %366 1 + %395 = OpCompositeExtract %float %388 0 + %396 = OpCompositeConstruct %v2float %394 %395 + %398 = OpLoad %int %h + OpStore %h %31 + OpStore %h %398 + %401 = OpFunctionCall %void %swap_i1_i1_ %param_2 %param_3 + %405 = OpLoad %int %l + OpStore %l %31 + OpStore %l %405 + %408 = OpCompositeExtract %float %216 2 + %409 = OpCompositeExtract %float %37 1 + %410 = OpCompositeConstruct %v2float %408 %409 + %411 = OpLoad %int %param_1 + OpStore %param_1 %31 + OpStore %param_1 %411 + %412 = OpLoad %int %i_1 + %413 = OpLoad %int %param + OpStore %param %31 + OpStore %param %413 + %414 = OpCompositeExtract %float %191 1 + %415 = OpCompositeExtract %float %191 0 + %416 = OpCompositeConstruct %v2float %414 %415 + %417 = OpLoad %int %j_1 + OpStore %j_1 %31 + OpStore %j_1 %417 + OpReturnValue %412 OpFunctionEnd - %quicksort_ = OpFunction %void None %419 - %421 = OpLabel + %quicksort_ = OpFunction %void None %418 + %420 = OpLabel %param_4 = OpVariable %_ptr_Function_int Function %31 %h_1 = OpVariable %_ptr_Function_int Function %31 %p = OpVariable %_ptr_Function_int Function %31 %l_1 = OpVariable %_ptr_Function_int Function %31 %top = OpVariable %_ptr_Function_int Function %31 - %stack = OpVariable %_ptr_Function__arr_int_uint_10 Function %429 + %stack = OpVariable %_ptr_Function__arr_int_uint_10 Function %428 %param_5 = OpVariable %_ptr_Function_int Function %31 - OpStore %l_1 %int_0 - %431 = OpLoad %int %param_5 - OpStore %param_5 %int_0 - OpStore %param_5 %431 + OpStore %l_1 %31 + %430 = OpLoad %int %param_5 + OpStore %param_5 %31 + OpStore %param_5 %430 OpStore %h_1 %int_9 - %433 = OpLoad %_arr_int_uint_10 %stack - OpStore %stack %102 - OpStore %stack %433 - %434 = OpCompositeExtract %float %38 1 - %435 = OpCompositeExtract %float %38 1 - %436 = OpCompositeConstruct %v2float %434 %435 - %437 = OpLoad %int %param_5 - OpStore %param_5 %int_0 - OpStore %param_5 %437 + %432 = OpLoad %_arr_int_uint_10 %stack + OpStore %stack %101 + OpStore %stack %432 + %433 = OpCompositeExtract %float %37 1 + %434 = OpCompositeExtract %float %37 1 + %435 = OpCompositeConstruct %v2float %433 %434 + %436 = OpLoad %int %param_5 + OpStore %param_5 %31 + OpStore %param_5 %436 OpStore %top %int_n1 - %439 = OpLoad %int %p - OpStore %p %int_0 - OpStore %p %439 - %440 = OpLoad %int %top - %441 = OpCompositeExtract %float %38 0 - %442 = OpCompositeExtract %float %38 0 - %443 = OpCompositeConstruct %v2float %441 %442 - %444 = OpLoad %int %p - OpStore %p %int_0 - OpStore %p %444 - %445 = OpBitcast %int %uint_1 - %446 = OpIAdd %int %440 %445 - %447 = OpLoad %int %top - OpStore %top %int_0 - OpStore %top %447 - %448 = OpCompositeExtract %float %436 1 - %449 = OpCompositeExtract %float %443 1 - %450 = OpCompositeConstruct %v2float %448 %449 - %451 = OpLoad %int %param_4 - OpStore %param_4 %int_0 - OpStore %param_4 %451 + %438 = OpLoad %int %p + OpStore %p %31 + OpStore %p %438 + %439 = OpLoad %int %top + %440 = OpCompositeExtract %float %37 0 + %441 = OpCompositeExtract %float %37 0 + %442 = OpCompositeConstruct %v2float %440 %441 + %443 = OpLoad %int %p + OpStore %p %31 + OpStore %p %443 + %444 = OpBitcast %int %uint_1 + %445 = OpIAdd %int %439 %444 + %446 = OpLoad %int %top + OpStore %top %31 OpStore %top %446 - %452 = OpLoad %int %h_1 - OpStore %h_1 %int_0 - OpStore %h_1 %452 - %453 = OpCompositeExtract %float %443 1 - %454 = OpCompositeExtract %float %443 0 - %455 = OpCompositeExtract %float %443 0 - %456 = OpCompositeConstruct %v3float %453 %454 %455 - %457 = OpLoad %int %param_4 - OpStore %param_4 %int_0 - OpStore %param_4 %457 - %458 = OpLoad %int %l_1 - %459 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %459 - %460 = OpCompositeExtract %float %456 1 - %461 = OpCompositeExtract %float %456 0 - %462 = OpCompositeExtract %float %443 0 - %463 = OpCompositeConstruct %v3float %460 %461 %462 - %464 = OpLoad %_arr_int_uint_10 %stack - OpStore %stack %102 - OpStore %stack %464 - %465 = OpCompositeExtract %float %436 1 - %466 = OpCompositeExtract %float %436 1 - %467 = OpCompositeExtract %float %436 1 - %468 = OpCompositeConstruct %v3float %465 %466 %467 - %469 = OpLoad %int %l_1 - OpStore %l_1 %int_0 - OpStore %l_1 %int_0 - %470 = OpAccessChain %_ptr_Function_int %stack %446 - OpStore %470 %458 - %471 = OpLoad %int %param_5 - OpStore %param_5 %int_0 - OpStore %param_5 %471 - %472 = OpLoad %int %top - %473 = OpLoad %int %param_4 - OpStore %param_4 %int_0 - OpStore %param_4 %473 - %474 = OpCompositeExtract %float %38 2 - %475 = OpCompositeExtract %float %450 1 - %476 = OpCompositeExtract %float %38 1 - %477 = OpCompositeConstruct %v3float %474 %475 %476 - %478 = OpAccessChain %_ptr_Function_int %stack %446 - %479 = OpLoad %int %478 - %480 = OpAccessChain %_ptr_Function_int %stack %446 - OpStore %480 %int_0 - %481 = OpAccessChain %_ptr_Function_int %stack %446 - OpStore %481 %479 - %482 = OpIAdd %int %472 %int_1 - %483 = OpAccessChain %_ptr_Function_int %stack %446 - %484 = OpLoad %int %483 - %485 = OpAccessChain %_ptr_Function_int %stack %446 - OpStore %485 %int_0 - %486 = OpAccessChain %_ptr_Function_int %stack %446 - OpStore %486 %484 - %487 = OpCompositeExtract %float %456 0 - %488 = OpCompositeExtract %float %456 2 - %489 = OpCompositeExtract %float %436 1 - %490 = OpCompositeConstruct %v3float %487 %488 %489 - OpStore %top %482 - %491 = OpLoad %int %param_4 - OpStore %param_4 %int_0 - OpStore %param_4 %491 - %492 = OpLoad %int %h_1 - %493 = OpLoad %int %param_4 - OpStore %param_4 %int_0 - OpStore %param_4 %493 - %494 = OpCompositeExtract %float %450 0 - %495 = OpCompositeExtract %float %468 0 - %496 = OpCompositeExtract %float %450 1 - %497 = OpCompositeConstruct %v3float %494 %495 %496 - %498 = OpLoad %int %l_1 - OpStore %l_1 %int_0 - OpStore %l_1 %498 - %499 = OpLoad %int %param_5 - OpStore %param_5 %int_0 - OpStore %param_5 %499 - %500 = OpCompositeExtract %float %497 2 - %501 = OpCompositeExtract %float %497 2 - %502 = OpCompositeConstruct %v2float %500 %501 - %503 = OpLoad %int %p - OpStore %p %int_0 - OpStore %p %503 - %504 = OpAccessChain %_ptr_Function_int %stack %482 - OpStore %504 %492 - OpBranch %505 - %505 = OpLabel - OpLoopMerge %506 %507 None - OpBranch %508 - %508 = OpLabel - %509 = OpCompositeExtract %float %490 0 - %510 = OpCompositeExtract %float %490 0 - %511 = OpCompositeExtract %float %490 0 - %512 = OpCompositeConstruct %v3float %509 %510 %511 - %513 = OpLoad %int %h_1 - OpStore %h_1 %int_0 - OpStore %h_1 %513 - %514 = OpLoad %_arr_int_uint_10 %stack - OpStore %stack %102 - OpStore %stack %514 - %515 = OpLoad %int %top - %516 = OpLoad %_arr_int_uint_10 %stack - OpStore %stack %102 - OpStore %stack %516 - %517 = OpCompositeExtract %float %450 0 - %518 = OpCompositeExtract %float %497 2 - %519 = OpCompositeConstruct %v2float %517 %518 - %520 = OpLoad %int %param_4 - OpStore %param_4 %int_0 - OpStore %param_4 %520 - %521 = OpBitcast %int %uint_0 - %522 = OpSGreaterThanEqual %bool %515 %521 + %447 = OpCompositeExtract %float %435 1 + %448 = OpCompositeExtract %float %442 1 + %449 = OpCompositeConstruct %v2float %447 %448 + %450 = OpLoad %int %param_4 + OpStore %param_4 %31 + OpStore %param_4 %450 + OpStore %top %445 + %451 = OpLoad %int %h_1 + OpStore %h_1 %31 + OpStore %h_1 %451 + %452 = OpCompositeExtract %float %442 1 + %453 = OpCompositeExtract %float %442 0 + %454 = OpCompositeExtract %float %442 0 + %455 = OpCompositeConstruct %v3float %452 %453 %454 + %456 = OpLoad %int %param_4 + OpStore %param_4 %31 + OpStore %param_4 %456 + %457 = OpLoad %int %l_1 + %458 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %458 + %459 = OpCompositeExtract %float %455 1 + %460 = OpCompositeExtract %float %455 0 + %461 = OpCompositeExtract %float %442 0 + %462 = OpCompositeConstruct %v3float %459 %460 %461 + %463 = OpLoad %_arr_int_uint_10 %stack + OpStore %stack %101 + OpStore %stack %463 + %464 = OpCompositeExtract %float %435 1 + %465 = OpCompositeExtract %float %435 1 + %466 = OpCompositeExtract %float %435 1 + %467 = OpCompositeConstruct %v3float %464 %465 %466 + %468 = OpLoad %int %l_1 + OpStore %l_1 %31 + OpStore %l_1 %31 + %469 = OpAccessChain %_ptr_Function_int %stack %445 + OpStore %469 %457 + %470 = OpLoad %int %param_5 + OpStore %param_5 %31 + OpStore %param_5 %470 + %471 = OpLoad %int %top + %472 = OpLoad %int %param_4 + OpStore %param_4 %31 + OpStore %param_4 %472 + %473 = OpCompositeExtract %float %37 2 + %474 = OpCompositeExtract %float %449 1 + %475 = OpCompositeExtract %float %37 1 + %476 = OpCompositeConstruct %v3float %473 %474 %475 + %477 = OpAccessChain %_ptr_Function_int %stack %445 + %478 = OpLoad %int %477 + %479 = OpAccessChain %_ptr_Function_int %stack %445 + OpStore %479 %31 + %480 = OpAccessChain %_ptr_Function_int %stack %445 + OpStore %480 %478 + %481 = OpIAdd %int %471 %int_1 + %482 = OpAccessChain %_ptr_Function_int %stack %445 + %483 = OpLoad %int %482 + %484 = OpAccessChain %_ptr_Function_int %stack %445 + OpStore %484 %31 + %485 = OpAccessChain %_ptr_Function_int %stack %445 + OpStore %485 %483 + %486 = OpCompositeExtract %float %455 0 + %487 = OpCompositeExtract %float %455 2 + %488 = OpCompositeExtract %float %435 1 + %489 = OpCompositeConstruct %v3float %486 %487 %488 + OpStore %top %481 + %490 = OpLoad %int %param_4 + OpStore %param_4 %31 + OpStore %param_4 %490 + %491 = OpLoad %int %h_1 + %492 = OpLoad %int %param_4 + OpStore %param_4 %31 + OpStore %param_4 %492 + %493 = OpCompositeExtract %float %449 0 + %494 = OpCompositeExtract %float %467 0 + %495 = OpCompositeExtract %float %449 1 + %496 = OpCompositeConstruct %v3float %493 %494 %495 + %497 = OpLoad %int %l_1 + OpStore %l_1 %31 + OpStore %l_1 %497 + %498 = OpLoad %int %param_5 + OpStore %param_5 %31 + OpStore %param_5 %498 + %499 = OpCompositeExtract %float %496 2 + %500 = OpCompositeExtract %float %496 2 + %501 = OpCompositeConstruct %v2float %499 %500 + %502 = OpLoad %int %p + OpStore %p %31 + OpStore %p %502 + %503 = OpAccessChain %_ptr_Function_int %stack %481 + OpStore %503 %491 + OpBranch %504 + %504 = OpLabel + OpLoopMerge %505 %506 None + OpBranch %507 + %507 = OpLabel + %508 = OpCompositeExtract %float %489 0 + %509 = OpCompositeExtract %float %489 0 + %510 = OpCompositeExtract %float %489 0 + %511 = OpCompositeConstruct %v3float %508 %509 %510 + %512 = OpLoad %int %h_1 + OpStore %h_1 %31 + OpStore %h_1 %512 + %513 = OpLoad %_arr_int_uint_10 %stack + OpStore %stack %101 + OpStore %stack %513 + %514 = OpLoad %int %top + %515 = OpLoad %_arr_int_uint_10 %stack + OpStore %stack %101 + OpStore %stack %515 + %516 = OpCompositeExtract %float %449 0 + %517 = OpCompositeExtract %float %496 2 + %518 = OpCompositeConstruct %v2float %516 %517 + %519 = OpLoad %int %param_4 + OpStore %param_4 %31 + OpStore %param_4 %519 + %520 = OpBitcast %int %521 + %522 = OpSGreaterThanEqual %bool %514 %520 OpSelectionMerge %523 None OpBranchConditional %522 %524 %525 %524 = OpLabel OpBranch %523 %525 = OpLabel - OpBranch %506 + OpBranch %505 %523 = OpLabel %526 = OpLoad %QuicksortObject %obj - OpStore %obj %103 + OpStore %obj %102 OpStore %obj %526 - %527 = OpCompositeExtract %float %456 1 - %528 = OpCompositeExtract %float %456 0 - %529 = OpCompositeExtract %float %490 1 + %527 = OpCompositeExtract %float %455 1 + %528 = OpCompositeExtract %float %455 0 + %529 = OpCompositeExtract %float %489 1 %530 = OpCompositeConstruct %v3float %527 %528 %529 %531 = OpLoad %int %param_4 - OpStore %param_4 %int_0 + OpStore %param_4 %31 OpStore %param_4 %531 %532 = OpLoad %int %top - %533 = OpCompositeExtract %float %502 0 - %534 = OpCompositeExtract %float %519 1 - %535 = OpCompositeExtract %float %502 0 + %533 = OpCompositeExtract %float %501 0 + %534 = OpCompositeExtract %float %518 1 + %535 = OpCompositeExtract %float %501 0 %536 = OpCompositeConstruct %v3float %533 %534 %535 %537 = OpLoad %int %h_1 - OpStore %h_1 %int_0 + OpStore %h_1 %31 OpStore %h_1 %537 - %538 = OpCompositeExtract %float %436 0 - %539 = OpCompositeExtract %float %436 0 + %538 = OpCompositeExtract %float %435 0 + %539 = OpCompositeExtract %float %435 0 %540 = OpCompositeConstruct %v2float %538 %539 %541 = OpLoad %int %p - OpStore %p %int_0 + OpStore %p %31 OpStore %p %541 %542 = OpBitcast %int %uint_1 %543 = OpISub %int %532 %542 OpStore %top %543 %544 = OpLoad %int %p - OpStore %p %int_0 + OpStore %p %31 OpStore %p %544 - %545 = OpAccessChain %_ptr_Function_int %stack %446 + %545 = OpAccessChain %_ptr_Function_int %stack %445 %546 = OpLoad %int %545 - %547 = OpAccessChain %_ptr_Function_int %stack %446 - OpStore %547 %int_0 - %548 = OpAccessChain %_ptr_Function_int %stack %446 + %547 = OpAccessChain %_ptr_Function_int %stack %445 + OpStore %547 %31 + %548 = OpAccessChain %_ptr_Function_int %stack %445 OpStore %548 %546 %549 = OpAccessChain %_ptr_Function_int %stack %532 %550 = OpLoad %int %549 %551 = OpLoad %_arr_int_uint_10 %stack - OpStore %stack %102 + OpStore %stack %101 OpStore %stack %551 - %552 = OpCompositeExtract %float %456 1 - %553 = OpCompositeExtract %float %456 0 - %554 = OpCompositeExtract %float %497 1 + %552 = OpCompositeExtract %float %455 1 + %553 = OpCompositeExtract %float %455 0 + %554 = OpCompositeExtract %float %496 1 %555 = OpCompositeConstruct %v3float %552 %553 %554 %556 = OpLoad %int %l_1 - OpStore %l_1 %int_0 + OpStore %l_1 %31 OpStore %l_1 %556 OpStore %h_1 %550 %557 = OpLoad %_arr_int_uint_10 %stack - OpStore %stack %102 + OpStore %stack %101 OpStore %stack %557 - %558 = OpCompositeExtract %float %477 1 - %559 = OpCompositeExtract %float %468 1 + %558 = OpCompositeExtract %float %476 1 + %559 = OpCompositeExtract %float %467 1 %560 = OpCompositeConstruct %v2float %558 %559 %561 = OpLoad %int %p - OpStore %p %int_0 + OpStore %p %31 OpStore %p %561 %562 = OpLoad %int %top %563 = OpLoad %int %param_4 - OpStore %param_4 %int_0 + OpStore %param_4 %31 OpStore %param_4 %563 - %564 = OpAccessChain %_ptr_Function_int %stack %482 + %564 = OpAccessChain %_ptr_Function_int %stack %481 %565 = OpLoad %int %564 - %566 = OpAccessChain %_ptr_Function_int %stack %482 - OpStore %566 %int_0 - %567 = OpAccessChain %_ptr_Function_int %stack %482 + %566 = OpAccessChain %_ptr_Function_int %stack %481 + OpStore %566 %31 + %567 = OpAccessChain %_ptr_Function_int %stack %481 OpStore %567 %565 - %568 = OpCompositeExtract %float %38 1 - %569 = OpCompositeExtract %float %38 2 + %568 = OpCompositeExtract %float %37 1 + %569 = OpCompositeExtract %float %37 2 %570 = OpCompositeConstruct %v2float %568 %569 %571 = OpISub %int %562 %int_1 OpStore %top %571 %572 = OpLoad %int %param_5 - OpStore %param_5 %int_0 + OpStore %param_5 %31 OpStore %param_5 %572 %573 = OpCompositeExtract %float %540 1 - %574 = OpCompositeExtract %float %502 0 + %574 = OpCompositeExtract %float %501 0 %575 = OpCompositeExtract %float %540 1 %576 = OpCompositeConstruct %v3float %573 %574 %575 %577 = OpLoad %int %h_1 - OpStore %h_1 %int_0 + OpStore %h_1 %31 OpStore %h_1 %577 - %578 = OpCompositeExtract %float %497 1 - %579 = OpCompositeExtract %float %497 2 + %578 = OpCompositeExtract %float %496 1 + %579 = OpCompositeExtract %float %496 2 %580 = OpCompositeConstruct %v2float %578 %579 - %581 = OpAccessChain %_ptr_Function_int %stack %482 + %581 = OpAccessChain %_ptr_Function_int %stack %481 %582 = OpLoad %int %581 - %583 = OpAccessChain %_ptr_Function_int %stack %482 - OpStore %583 %int_0 - %584 = OpAccessChain %_ptr_Function_int %stack %482 + %583 = OpAccessChain %_ptr_Function_int %stack %481 + OpStore %583 %31 + %584 = OpAccessChain %_ptr_Function_int %stack %481 OpStore %584 %582 %585 = OpAccessChain %_ptr_Function_int %stack %562 %586 = OpLoad %int %585 %587 = OpLoad %int %p - OpStore %p %int_0 + OpStore %p %31 OpStore %p %587 %588 = OpCompositeExtract %float %570 1 %589 = OpCompositeExtract %float %570 1 - %590 = OpCompositeExtract %float %502 0 + %590 = OpCompositeExtract %float %501 0 %591 = OpCompositeConstruct %v3float %588 %589 %590 %592 = OpLoad %int %param_5 - OpStore %param_5 %int_0 + OpStore %param_5 %31 OpStore %param_5 %592 OpStore %l_1 %586 %593 = OpLoad %int %top - OpStore %top %int_0 + OpStore %top %31 OpStore %top %593 %594 = OpLoad %int %l_1 OpStore %param_4 %594 %595 = OpAccessChain %_ptr_Function_int %stack %532 %596 = OpLoad %int %595 %597 = OpAccessChain %_ptr_Function_int %stack %532 - OpStore %597 %int_0 + OpStore %597 %31 %598 = OpAccessChain %_ptr_Function_int %stack %532 OpStore %598 %596 %599 = OpCompositeExtract %float %536 1 %600 = OpCompositeExtract %float %536 2 %601 = OpCompositeConstruct %v2float %599 %600 %602 = OpLoad %int %h_1 - %603 = OpCompositeExtract %float %450 0 - %604 = OpCompositeExtract %float %38 1 + %603 = OpCompositeExtract %float %449 0 + %604 = OpCompositeExtract %float %37 1 %605 = OpCompositeConstruct %v2float %603 %604 OpStore %param_5 %602 - %606 = OpAccessChain %_ptr_Function_int %stack %482 + %606 = OpAccessChain %_ptr_Function_int %stack %481 %607 = OpLoad %int %606 - %608 = OpAccessChain %_ptr_Function_int %stack %482 - OpStore %608 %int_0 - %609 = OpAccessChain %_ptr_Function_int %stack %482 + %608 = OpAccessChain %_ptr_Function_int %stack %481 + OpStore %608 %31 + %609 = OpAccessChain %_ptr_Function_int %stack %481 OpStore %609 %607 %610 = OpFunctionCall %int %performPartition_i1_i1_ %param_4 %param_5 - %613 = OpCompositeExtract %float %519 0 + %613 = OpCompositeExtract %float %518 0 %614 = OpCompositeExtract %float %530 0 %615 = OpCompositeConstruct %v2float %613 %614 %616 = OpLoad %int %param_5 - OpStore %param_5 %int_0 + OpStore %param_5 %31 OpStore %param_5 %616 OpStore %p %610 %617 = OpLoad %int %param_4 - OpStore %param_4 %int_0 + OpStore %param_4 %31 OpStore %param_4 %617 %618 = OpLoad %int %p %619 = OpLoad %int %h_1 - OpStore %h_1 %int_0 + OpStore %h_1 %31 OpStore %h_1 %619 %620 = OpCompositeExtract %float %530 1 %621 = OpCompositeExtract %float %530 1 %622 = OpCompositeConstruct %v2float %620 %621 %623 = OpLoad %int %l_1 - OpStore %l_1 %int_0 + OpStore %l_1 %31 OpStore %l_1 %623 %624 = OpLoad %int %h_1 - OpStore %h_1 %int_0 + OpStore %h_1 %31 OpStore %h_1 %624 %625 = OpLoad %int %l_1 %626 = OpAccessChain %_ptr_Function_int %stack %532 %627 = OpLoad %int %626 %628 = OpAccessChain %_ptr_Function_int %stack %532 - OpStore %628 %int_0 + OpStore %628 %31 %629 = OpAccessChain %_ptr_Function_int %stack %532 OpStore %629 %627 %630 = OpLoad %int %h_1 - OpStore %h_1 %int_0 + OpStore %h_1 %31 OpStore %h_1 %630 - %631 = OpCompositeExtract %float %519 1 + %631 = OpCompositeExtract %float %518 1 %632 = OpCompositeExtract %float %570 0 %633 = OpCompositeConstruct %v2float %631 %632 - %634 = OpAccessChain %_ptr_Function_int %stack %482 + %634 = OpAccessChain %_ptr_Function_int %stack %481 %635 = OpLoad %int %634 - %636 = OpAccessChain %_ptr_Function_int %stack %482 - OpStore %636 %int_0 - %637 = OpAccessChain %_ptr_Function_int %stack %482 + %636 = OpAccessChain %_ptr_Function_int %stack %481 + OpStore %636 %31 + %637 = OpAccessChain %_ptr_Function_int %stack %481 OpStore %637 %635 %638 = OpBitcast %int %uint_1 %639 = OpISub %int %618 %638 @@ -951,20 +949,20 @@ OpBranchConditional %640 %642 %641 %642 = OpLabel %643 = OpLoad %int %param_4 - OpStore %param_4 %int_0 + OpStore %param_4 %31 OpStore %param_4 %643 %644 = OpLoad %int %top %645 = OpCompositeExtract %float %555 1 - %646 = OpCompositeExtract %float %436 1 + %646 = OpCompositeExtract %float %435 1 %647 = OpCompositeConstruct %v2float %645 %646 - %648 = OpAccessChain %_ptr_Function_int %stack %482 + %648 = OpAccessChain %_ptr_Function_int %stack %481 %649 = OpLoad %int %648 - %650 = OpAccessChain %_ptr_Function_int %stack %482 - OpStore %650 %int_0 - %651 = OpAccessChain %_ptr_Function_int %stack %482 + %650 = OpAccessChain %_ptr_Function_int %stack %481 + OpStore %650 %31 + %651 = OpAccessChain %_ptr_Function_int %stack %481 OpStore %651 %649 %652 = OpLoad %_arr_int_uint_10 %stack - OpStore %stack %102 + OpStore %stack %101 OpStore %stack %652 %653 = OpCompositeExtract %float %536 2 %654 = OpCompositeExtract %float %536 1 @@ -977,37 +975,37 @@ %661 = OpAccessChain %_ptr_Function_int %stack %562 %662 = OpLoad %int %661 %663 = OpAccessChain %_ptr_Function_int %stack %562 - OpStore %663 %int_0 + OpStore %663 %31 %664 = OpAccessChain %_ptr_Function_int %stack %562 OpStore %664 %662 - %665 = OpCompositeExtract %float %497 0 + %665 = OpCompositeExtract %float %496 0 %666 = OpCompositeExtract %float %659 0 %667 = OpCompositeConstruct %v2float %665 %666 %668 = OpLoad %int %param_5 - OpStore %param_5 %int_0 + OpStore %param_5 %31 OpStore %param_5 %668 %669 = OpIAdd %int %int_1 %644 %670 = OpAccessChain %_ptr_Function_int %stack %532 %671 = OpLoad %int %670 %672 = OpAccessChain %_ptr_Function_int %stack %532 - OpStore %672 %int_0 + OpStore %672 %31 %673 = OpAccessChain %_ptr_Function_int %stack %532 OpStore %673 %671 - %674 = OpCompositeExtract %float %512 1 - %675 = OpCompositeExtract %float %512 1 - %676 = OpCompositeExtract %float %490 0 + %674 = OpCompositeExtract %float %511 1 + %675 = OpCompositeExtract %float %511 1 + %676 = OpCompositeExtract %float %489 0 %677 = OpCompositeConstruct %v3float %674 %675 %676 %678 = OpLoad %int %param_5 - OpStore %param_5 %int_0 + OpStore %param_5 %31 OpStore %param_5 %678 %679 = OpAccessChain %_ptr_Function_int %stack %669 OpStore %679 %660 %680 = OpLoad %int %top - %681 = OpAccessChain %_ptr_Function_int %stack %482 + %681 = OpAccessChain %_ptr_Function_int %stack %481 %682 = OpLoad %int %681 - %683 = OpAccessChain %_ptr_Function_int %stack %482 - OpStore %683 %int_0 - %684 = OpAccessChain %_ptr_Function_int %stack %482 + %683 = OpAccessChain %_ptr_Function_int %stack %481 + OpStore %683 %31 + %684 = OpAccessChain %_ptr_Function_int %stack %481 OpStore %684 %682 %685 = OpCompositeExtract %float %580 1 %686 = OpCompositeExtract %float %580 0 @@ -1015,28 +1013,28 @@ %688 = OpAccessChain %_ptr_Function_int %stack %669 %689 = OpLoad %int %688 %690 = OpAccessChain %_ptr_Function_int %stack %669 - OpStore %690 %int_0 + OpStore %690 %31 %691 = OpAccessChain %_ptr_Function_int %stack %669 OpStore %691 %689 %693 = OpBitcast %uint %680 %694 = OpIAdd %uint %uint_1 %693 %692 = OpBitcast %int %694 - %695 = OpAccessChain %_ptr_Function_int %stack %482 + %695 = OpAccessChain %_ptr_Function_int %stack %481 %696 = OpLoad %int %695 - %697 = OpAccessChain %_ptr_Function_int %stack %482 - OpStore %697 %int_0 - %698 = OpAccessChain %_ptr_Function_int %stack %482 + %697 = OpAccessChain %_ptr_Function_int %stack %481 + OpStore %697 %31 + %698 = OpAccessChain %_ptr_Function_int %stack %481 OpStore %698 %696 %699 = OpCompositeExtract %float %591 2 %700 = OpCompositeExtract %float %687 1 %701 = OpCompositeExtract %float %591 2 %702 = OpCompositeConstruct %v3float %699 %700 %701 %703 = OpLoad %int %h_1 - OpStore %h_1 %int_0 + OpStore %h_1 %31 OpStore %h_1 %703 OpStore %top %692 %704 = OpLoad %_arr_int_uint_10 %stack - OpStore %stack %102 + OpStore %stack %101 OpStore %stack %704 %705 = OpLoad %int %p %706 = OpCompositeExtract %float %591 0 @@ -1045,24 +1043,24 @@ %709 = OpAccessChain %_ptr_Function_int %stack %562 %710 = OpLoad %int %709 %711 = OpAccessChain %_ptr_Function_int %stack %562 - OpStore %711 %int_0 + OpStore %711 %31 %712 = OpAccessChain %_ptr_Function_int %stack %562 OpStore %712 %710 %713 = OpAccessChain %_ptr_Function_int %stack %562 %714 = OpLoad %int %713 %715 = OpAccessChain %_ptr_Function_int %stack %562 - OpStore %715 %int_0 + OpStore %715 %31 %716 = OpAccessChain %_ptr_Function_int %stack %562 OpStore %716 %714 %717 = OpAccessChain %_ptr_Function_int %stack %692 %718 = OpBitcast %int %uint_1 %719 = OpISub %int %705 %718 OpStore %717 %719 - %720 = OpAccessChain %_ptr_Function_int %stack %446 + %720 = OpAccessChain %_ptr_Function_int %stack %445 %721 = OpLoad %int %720 - %722 = OpAccessChain %_ptr_Function_int %stack %446 - OpStore %722 %int_0 - %723 = OpAccessChain %_ptr_Function_int %stack %446 + %722 = OpAccessChain %_ptr_Function_int %stack %445 + OpStore %722 %31 + %723 = OpAccessChain %_ptr_Function_int %stack %445 OpStore %723 %721 %724 = OpCompositeExtract %float %536 2 %725 = OpCompositeExtract %float %536 1 @@ -1070,63 +1068,63 @@ %727 = OpAccessChain %_ptr_Function_int %stack %692 %728 = OpLoad %int %727 %729 = OpAccessChain %_ptr_Function_int %stack %692 - OpStore %729 %int_0 + OpStore %729 %31 %730 = OpAccessChain %_ptr_Function_int %stack %692 OpStore %730 %728 OpBranch %641 %641 = OpLabel - %731 = OpAccessChain %_ptr_Function_int %stack %446 + %731 = OpAccessChain %_ptr_Function_int %stack %445 %732 = OpLoad %int %731 - %733 = OpAccessChain %_ptr_Function_int %stack %446 - OpStore %733 %int_0 - %734 = OpAccessChain %_ptr_Function_int %stack %446 + %733 = OpAccessChain %_ptr_Function_int %stack %445 + OpStore %733 %31 + %734 = OpAccessChain %_ptr_Function_int %stack %445 OpStore %734 %732 - %735 = OpCompositeExtract %float %38 0 - %736 = OpCompositeExtract %float %38 1 + %735 = OpCompositeExtract %float %37 0 + %736 = OpCompositeExtract %float %37 1 %737 = OpCompositeConstruct %v2float %735 %736 %738 = OpLoad %QuicksortObject %obj - OpStore %obj %103 + OpStore %obj %102 OpStore %obj %738 %739 = OpLoad %int %p %740 = OpAccessChain %_ptr_Function_int %stack %562 %741 = OpLoad %int %740 %742 = OpAccessChain %_ptr_Function_int %stack %562 - OpStore %742 %int_0 + OpStore %742 %31 %743 = OpAccessChain %_ptr_Function_int %stack %562 OpStore %743 %741 %744 = OpCompositeExtract %float %555 2 - %745 = OpCompositeExtract %float %436 0 - %746 = OpCompositeExtract %float %436 1 + %745 = OpCompositeExtract %float %435 0 + %746 = OpCompositeExtract %float %435 1 %747 = OpCompositeConstruct %v3float %744 %745 %746 %748 = OpLoad %int %p - OpStore %p %int_0 + OpStore %p %31 OpStore %p %748 - %749 = OpCompositeExtract %float %490 2 - %750 = OpCompositeExtract %float %490 0 + %749 = OpCompositeExtract %float %489 2 + %750 = OpCompositeExtract %float %489 0 %751 = OpCompositeExtract %float %580 0 %752 = OpCompositeConstruct %v3float %749 %750 %751 %753 = OpAccessChain %_ptr_Function_int %stack %562 %754 = OpLoad %int %753 %755 = OpAccessChain %_ptr_Function_int %stack %562 - OpStore %755 %int_0 + OpStore %755 %31 %756 = OpAccessChain %_ptr_Function_int %stack %562 OpStore %756 %754 %757 = OpLoad %int %h_1 %758 = OpLoad %int %top - OpStore %top %int_0 + OpStore %top %31 OpStore %top %758 - %759 = OpCompositeExtract %float %463 2 + %759 = OpCompositeExtract %float %462 2 %760 = OpCompositeExtract %float %530 0 - %761 = OpCompositeExtract %float %463 0 + %761 = OpCompositeExtract %float %462 0 %762 = OpCompositeConstruct %v3float %759 %760 %761 - %763 = OpAccessChain %_ptr_Function_int %stack %482 + %763 = OpAccessChain %_ptr_Function_int %stack %481 %764 = OpLoad %int %763 - %765 = OpAccessChain %_ptr_Function_int %stack %482 - OpStore %765 %int_0 - %766 = OpAccessChain %_ptr_Function_int %stack %482 + %765 = OpAccessChain %_ptr_Function_int %stack %481 + OpStore %765 %31 + %766 = OpAccessChain %_ptr_Function_int %stack %481 OpStore %766 %764 %767 = OpLoad %int %p - OpStore %p %int_0 + OpStore %p %31 OpStore %p %767 %769 = OpBitcast %uint %739 %770 = OpIAdd %uint %uint_1 %769 @@ -1138,66 +1136,66 @@ %774 = OpAccessChain %_ptr_Function_int %stack %562 %775 = OpLoad %int %774 %776 = OpAccessChain %_ptr_Function_int %stack %562 - OpStore %776 %int_0 + OpStore %776 %31 %777 = OpAccessChain %_ptr_Function_int %stack %562 OpStore %777 %775 %778 = OpCompositeExtract %float %737 1 %779 = OpCompositeExtract %float %633 0 %780 = OpCompositeConstruct %v2float %778 %779 %781 = OpLoad %int %l_1 - OpStore %l_1 %int_0 + OpStore %l_1 %31 OpStore %l_1 %781 %782 = OpLoad %int %top %783 = OpAccessChain %_ptr_Function_int %stack %562 %784 = OpLoad %int %783 %785 = OpAccessChain %_ptr_Function_int %stack %562 - OpStore %785 %int_0 + OpStore %785 %31 %786 = OpAccessChain %_ptr_Function_int %stack %562 OpStore %786 %784 - %787 = OpCompositeExtract %float %477 1 - %788 = OpCompositeExtract %float %463 1 - %789 = OpCompositeExtract %float %463 1 + %787 = OpCompositeExtract %float %476 1 + %788 = OpCompositeExtract %float %462 1 + %789 = OpCompositeExtract %float %462 1 %790 = OpCompositeConstruct %v3float %787 %788 %789 %791 = OpIAdd %int %782 %int_1 %792 = OpLoad %int %param_5 - OpStore %param_5 %int_0 + OpStore %param_5 %31 OpStore %param_5 %792 OpStore %top %791 %793 = OpAccessChain %_ptr_Function_int %stack %562 %794 = OpLoad %int %793 %795 = OpAccessChain %_ptr_Function_int %stack %562 - OpStore %795 %int_0 + OpStore %795 %31 %796 = OpAccessChain %_ptr_Function_int %stack %562 OpStore %796 %794 %797 = OpLoad %int %p %798 = OpLoad %int %param_5 - OpStore %param_5 %int_0 + OpStore %param_5 %31 OpStore %param_5 %798 - %799 = OpCompositeExtract %float %463 2 - %800 = OpCompositeExtract %float %463 0 + %799 = OpCompositeExtract %float %462 2 + %800 = OpCompositeExtract %float %462 0 %801 = OpCompositeExtract %float %530 0 %802 = OpCompositeConstruct %v3float %799 %800 %801 %803 = OpLoad %int %p - OpStore %p %int_0 + OpStore %p %31 OpStore %p %803 - %804 = OpCompositeExtract %float %436 0 + %804 = OpCompositeExtract %float %435 0 %805 = OpCompositeExtract %float %622 0 %806 = OpCompositeExtract %float %622 0 %807 = OpCompositeConstruct %v3float %804 %805 %806 - %808 = OpAccessChain %_ptr_Function_int %stack %482 + %808 = OpAccessChain %_ptr_Function_int %stack %481 %809 = OpLoad %int %808 - %810 = OpAccessChain %_ptr_Function_int %stack %482 - OpStore %810 %int_0 - %811 = OpAccessChain %_ptr_Function_int %stack %482 + %810 = OpAccessChain %_ptr_Function_int %stack %481 + OpStore %810 %31 + %811 = OpAccessChain %_ptr_Function_int %stack %481 OpStore %811 %809 %812 = OpAccessChain %_ptr_Function_int %stack %532 %813 = OpLoad %int %812 %814 = OpAccessChain %_ptr_Function_int %stack %532 - OpStore %814 %int_0 + OpStore %814 %31 %815 = OpAccessChain %_ptr_Function_int %stack %532 OpStore %815 %813 - %816 = OpCompositeExtract %float %490 0 - %817 = OpCompositeExtract %float %490 1 + %816 = OpCompositeExtract %float %489 0 + %817 = OpCompositeExtract %float %489 1 %818 = OpCompositeConstruct %v2float %816 %817 %819 = OpAccessChain %_ptr_Function_int %stack %791 %821 = OpBitcast %uint %797 @@ -1205,1439 +1203,1439 @@ %820 = OpBitcast %int %822 OpStore %819 %820 %823 = OpLoad %_arr_int_uint_10 %stack - OpStore %stack %102 + OpStore %stack %101 OpStore %stack %823 %824 = OpLoad %int %top %825 = OpAccessChain %_ptr_Function_int %stack %562 %826 = OpLoad %int %825 %827 = OpAccessChain %_ptr_Function_int %stack %562 - OpStore %827 %int_0 + OpStore %827 %31 %828 = OpAccessChain %_ptr_Function_int %stack %562 OpStore %828 %826 - %829 = OpCompositeExtract %float %502 1 + %829 = OpCompositeExtract %float %501 1 %830 = OpCompositeExtract %float %802 1 %831 = OpCompositeConstruct %v2float %829 %830 %832 = OpLoad %_arr_int_uint_10 %stack - OpStore %stack %102 + OpStore %stack %101 OpStore %stack %832 %833 = OpBitcast %int %uint_1 %834 = OpIAdd %int %824 %833 %835 = OpAccessChain %_ptr_Function_int %stack %791 %836 = OpLoad %int %835 %837 = OpAccessChain %_ptr_Function_int %stack %791 - OpStore %837 %int_0 + OpStore %837 %31 %838 = OpAccessChain %_ptr_Function_int %stack %791 OpStore %838 %836 OpStore %top %834 %839 = OpLoad %int %param_4 - OpStore %param_4 %int_0 + OpStore %param_4 %31 OpStore %param_4 %839 %840 = OpLoad %int %h_1 - %841 = OpAccessChain %_ptr_Function_int %stack %482 + %841 = OpAccessChain %_ptr_Function_int %stack %481 %842 = OpLoad %int %841 - %843 = OpAccessChain %_ptr_Function_int %stack %482 - OpStore %843 %int_0 - %844 = OpAccessChain %_ptr_Function_int %stack %482 + %843 = OpAccessChain %_ptr_Function_int %stack %481 + OpStore %843 %31 + %844 = OpAccessChain %_ptr_Function_int %stack %481 OpStore %844 %842 - %845 = OpAccessChain %_ptr_Function_int %stack %446 + %845 = OpAccessChain %_ptr_Function_int %stack %445 %846 = OpLoad %int %845 - %847 = OpAccessChain %_ptr_Function_int %stack %446 - OpStore %847 %int_0 - %848 = OpAccessChain %_ptr_Function_int %stack %446 + %847 = OpAccessChain %_ptr_Function_int %stack %445 + OpStore %847 %31 + %848 = OpAccessChain %_ptr_Function_int %stack %445 OpStore %848 %846 %849 = OpAccessChain %_ptr_Function_int %stack %834 OpStore %849 %840 %850 = OpAccessChain %_ptr_Function_int %stack %562 %851 = OpLoad %int %850 %852 = OpAccessChain %_ptr_Function_int %stack %562 - OpStore %852 %int_0 + OpStore %852 %31 %853 = OpAccessChain %_ptr_Function_int %stack %562 OpStore %853 %851 %854 = OpCompositeExtract %float %530 1 - %855 = OpCompositeExtract %float %497 0 - %856 = OpCompositeExtract %float %497 0 + %855 = OpCompositeExtract %float %496 0 + %856 = OpCompositeExtract %float %496 0 %857 = OpCompositeConstruct %v3float %854 %855 %856 %858 = OpLoad %int %l_1 - OpStore %l_1 %int_0 + OpStore %l_1 %31 OpStore %l_1 %858 OpBranch %772 %772 = OpLabel - %859 = OpAccessChain %_ptr_Function_int %stack %482 + %859 = OpAccessChain %_ptr_Function_int %stack %481 %860 = OpLoad %int %859 - %861 = OpAccessChain %_ptr_Function_int %stack %482 - OpStore %861 %int_0 - %862 = OpAccessChain %_ptr_Function_int %stack %482 + %861 = OpAccessChain %_ptr_Function_int %stack %481 + OpStore %861 %31 + %862 = OpAccessChain %_ptr_Function_int %stack %481 OpStore %862 %860 - OpBranch %507 - %507 = OpLabel + OpBranch %506 + %506 = OpLabel %863 = OpLoad %int %l_1 - OpStore %l_1 %int_0 + OpStore %l_1 %31 OpStore %l_1 %863 - %864 = OpCompositeExtract %float %490 2 - %865 = OpCompositeExtract %float %497 0 + %864 = OpCompositeExtract %float %489 2 + %865 = OpCompositeExtract %float %496 0 %866 = OpCompositeConstruct %v2float %864 %865 %867 = OpLoad %QuicksortObject %obj - OpStore %obj %103 + OpStore %obj %102 OpStore %obj %867 - OpBranch %505 - %506 = OpLabel + OpBranch %504 + %505 = OpLabel %868 = OpLoad %int %h_1 - OpStore %h_1 %int_0 + OpStore %h_1 %31 OpStore %h_1 %868 OpReturn OpFunctionEnd - %main_1 = OpFunction %void None %419 + %main_1 = OpFunction %void None %418 %870 = OpLabel - %color = OpVariable %_ptr_Function_v3float Function %171 + %color = OpVariable %_ptr_Function_v3float Function %170 %i_2 = OpVariable %_ptr_Function_int Function %31 - %uv = OpVariable %_ptr_Function_v2float Function %168 + %uv = OpVariable %_ptr_Function_v2float Function %167 %874 = OpLoad %v2float %uv - OpStore %uv %876 + OpStore %uv %167 OpStore %uv %874 - OpStore %i_2 %int_0 - %877 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %877 - OpSelectionMerge %879 None - OpBranchConditional %true %880 %879 - %880 = OpLabel - %881 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %881 - %882 = OpCompositeExtract %float %38 0 - %883 = OpCompositeExtract %float %38 0 - %884 = OpCompositeConstruct %v2float %882 %883 - %885 = OpLoad %int %i_2 - %886 = OpLoad %v2float %uv - OpStore %uv %876 - OpStore %uv %886 - %887 = OpLoad %v3float %color - OpStore %color %888 - OpStore %color %887 - %889 = OpCompositeExtract %float %884 1 - %890 = OpCompositeExtract %float %884 1 - %891 = OpCompositeConstruct %v2float %889 %890 - %892 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %892 - OpBranch %879 - %879 = OpLabel - %893 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %893 - %894 = OpCompositeExtract %float %168 0 - %895 = OpCompositeExtract %float %168 0 - %896 = OpCompositeConstruct %v2float %894 %895 - %897 = OpLoad %int %i_2 - OpStore %i_2 %int_0 - OpStore %i_2 %897 - %898 = OpFunctionCall %void %quicksort_ - %899 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %899 - %900 = OpLoad %v4float %gl_FragCoord - %901 = OpLoad %v2float %uv - OpStore %uv %876 - OpStore %uv %901 - %902 = OpCompositeExtract %float %168 1 - %903 = OpCompositeExtract %float %168 1 - %904 = OpCompositeConstruct %v2float %902 %903 - %905 = OpLoad %v2float %uv - OpStore %uv %876 - OpStore %uv %905 - %906 = OpCompositeExtract %float %900 0 - %907 = OpCompositeExtract %float %900 1 - %908 = OpCompositeConstruct %v2float %906 %907 - %909 = OpCompositeExtract %float %908 1 - %910 = OpCompositeExtract %float %896 1 - %911 = OpCompositeExtract %float %896 1 - %912 = OpCompositeConstruct %v3float %909 %910 %911 - %913 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %913 - %914 = OpLoad %v2float %uv - OpStore %uv %876 - OpStore %uv %914 - %916 = OpAccessChain %_ptr_Uniform_v2float %x_188 %uint_0 - %917 = OpLoad %v2float %916 - %918 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %918 - %919 = OpCompositeExtract %float %900 1 - %920 = OpCompositeExtract %float %38 2 - %921 = OpCompositeExtract %float %900 3 - %922 = OpCompositeConstruct %v3float %919 %920 %921 - %923 = OpLoad %v3float %color - OpStore %color %888 - OpStore %color %923 - %924 = OpFDiv %v2float %908 %917 - %925 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %925 - %926 = OpCompositeExtract %float %904 0 - %927 = OpCompositeExtract %float %908 1 - %928 = OpCompositeConstruct %v2float %926 %927 - %929 = OpLoad %v3float %color - OpStore %color %888 - %930 = OpLoad %v3float %color - OpStore %color %888 - OpStore %color %930 - OpStore %color %929 - OpStore %uv %924 - OpStore %color %38 - %931 = OpLoad %v3float %color - OpStore %color %888 - OpStore %color %931 - %932 = OpCompositeExtract %float %908 0 - %933 = OpCompositeExtract %float %908 1 - %934 = OpCompositeExtract %float %896 1 - %935 = OpCompositeConstruct %v3float %932 %933 %934 - %936 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %936 - %937 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - %938 = OpLoad %int %937 - %939 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - OpStore %939 %int_0 - %940 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - OpStore %940 %938 - %941 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 + OpStore %i_2 %31 + %875 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %875 + OpSelectionMerge %877 None + OpBranchConditional %true %878 %877 + %878 = OpLabel + %879 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %879 + %880 = OpCompositeExtract %float %37 0 + %881 = OpCompositeExtract %float %37 0 + %882 = OpCompositeConstruct %v2float %880 %881 + %883 = OpLoad %int %i_2 + %884 = OpLoad %v2float %uv + OpStore %uv %167 + OpStore %uv %884 + %885 = OpLoad %v3float %color + OpStore %color %170 + OpStore %color %885 + %886 = OpCompositeExtract %float %882 1 + %887 = OpCompositeExtract %float %882 1 + %888 = OpCompositeConstruct %v2float %886 %887 + %889 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %889 + OpBranch %877 + %877 = OpLabel + %890 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %890 + %891 = OpCompositeExtract %float %167 0 + %892 = OpCompositeExtract %float %167 0 + %893 = OpCompositeConstruct %v2float %891 %892 + %894 = OpLoad %int %i_2 + OpStore %i_2 %31 + OpStore %i_2 %894 + %895 = OpFunctionCall %void %quicksort_ + %896 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %896 + %897 = OpLoad %v4float %gl_FragCoord + %898 = OpLoad %v2float %uv + OpStore %uv %167 + OpStore %uv %898 + %899 = OpCompositeExtract %float %167 1 + %900 = OpCompositeExtract %float %167 1 + %901 = OpCompositeConstruct %v2float %899 %900 + %902 = OpLoad %v2float %uv + OpStore %uv %167 + OpStore %uv %902 + %903 = OpCompositeExtract %float %897 0 + %904 = OpCompositeExtract %float %897 1 + %905 = OpCompositeConstruct %v2float %903 %904 + %906 = OpCompositeExtract %float %905 1 + %907 = OpCompositeExtract %float %893 1 + %908 = OpCompositeExtract %float %893 1 + %909 = OpCompositeConstruct %v3float %906 %907 %908 + %910 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %910 + %911 = OpLoad %v2float %uv + OpStore %uv %167 + OpStore %uv %911 + %913 = OpAccessChain %_ptr_Uniform_v2float %x_188 %uint_0 + %914 = OpLoad %v2float %913 + %915 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %915 + %916 = OpCompositeExtract %float %897 1 + %917 = OpCompositeExtract %float %37 2 + %918 = OpCompositeExtract %float %897 3 + %919 = OpCompositeConstruct %v3float %916 %917 %918 + %920 = OpLoad %v3float %color + OpStore %color %170 + OpStore %color %920 + %921 = OpFDiv %v2float %905 %914 + %922 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %922 + %923 = OpCompositeExtract %float %901 0 + %924 = OpCompositeExtract %float %905 1 + %925 = OpCompositeConstruct %v2float %923 %924 + %926 = OpLoad %v3float %color + OpStore %color %170 + %927 = OpLoad %v3float %color + OpStore %color %170 + OpStore %color %927 + OpStore %color %926 + OpStore %uv %921 + OpStore %color %37 + %928 = OpLoad %v3float %color + OpStore %color %170 + OpStore %color %928 + %929 = OpCompositeExtract %float %905 0 + %930 = OpCompositeExtract %float %905 1 + %931 = OpCompositeExtract %float %893 1 + %932 = OpCompositeConstruct %v3float %929 %930 %931 + %933 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %933 + %934 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + %935 = OpLoad %int %934 + %936 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + OpStore %936 %31 + %937 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + OpStore %937 %935 + %938 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + %939 = OpLoad %int %938 + %940 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %940 + %941 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 %942 = OpLoad %int %941 - %943 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %943 - %944 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - %945 = OpLoad %int %944 - %946 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - OpStore %946 %int_0 - %947 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - OpStore %947 %945 - %948 = OpAccessChain %_ptr_Function_float %color %uint_0 - %949 = OpLoad %float %948 - %950 = OpAccessChain %_ptr_Function_float %color %uint_0 - %951 = OpLoad %float %950 - %952 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %952 %float_0 - %953 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %953 %951 - %954 = OpCompositeExtract %float %38 2 - %955 = OpCompositeExtract %float %38 1 - %956 = OpCompositeConstruct %v2float %954 %955 - %957 = OpLoad %int %i_2 - OpStore %i_2 %int_0 - OpStore %i_2 %957 - %958 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %958 - %959 = OpCompositeExtract %float %935 0 - %960 = OpCompositeExtract %float %928 0 - %961 = OpCompositeExtract %float %928 1 - %962 = OpCompositeConstruct %v3float %959 %960 %961 - %963 = OpAccessChain %_ptr_Function_float %color %uint_0 - %964 = OpConvertSToF %float %942 - %965 = OpFAdd %float %949 %964 - OpStore %963 %965 - %966 = OpLoad %v2float %uv - OpStore %uv %876 - OpStore %uv %966 - %967 = OpLoad %v2float %uv - OpStore %uv %876 - OpStore %uv %967 - %968 = OpCompositeExtract %float %900 1 - %969 = OpCompositeExtract %float %900 1 - %970 = OpCompositeConstruct %v2float %968 %969 - %971 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %972 = OpLoad %float %971 - %973 = OpCompositeExtract %float %924 1 - %974 = OpCompositeExtract %float %924 0 - %975 = OpCompositeConstruct %v2float %973 %974 + %943 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + OpStore %943 %31 + %944 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + OpStore %944 %942 + %945 = OpAccessChain %_ptr_Function_float %color %uint_0 + %946 = OpLoad %float %945 + %947 = OpAccessChain %_ptr_Function_float %color %uint_0 + %948 = OpLoad %float %947 + %949 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %949 %950 + %951 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %951 %948 + %952 = OpCompositeExtract %float %37 2 + %953 = OpCompositeExtract %float %37 1 + %954 = OpCompositeConstruct %v2float %952 %953 + %955 = OpLoad %int %i_2 + OpStore %i_2 %31 + OpStore %i_2 %955 + %956 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %956 + %957 = OpCompositeExtract %float %932 0 + %958 = OpCompositeExtract %float %925 0 + %959 = OpCompositeExtract %float %925 1 + %960 = OpCompositeConstruct %v3float %957 %958 %959 + %961 = OpAccessChain %_ptr_Function_float %color %uint_0 + %962 = OpConvertSToF %float %939 + %963 = OpFAdd %float %946 %962 + OpStore %961 %963 + %964 = OpLoad %v2float %uv + OpStore %uv %167 + OpStore %uv %964 + %965 = OpLoad %v2float %uv + OpStore %uv %167 + OpStore %uv %965 + %966 = OpCompositeExtract %float %897 1 + %967 = OpCompositeExtract %float %897 1 + %968 = OpCompositeConstruct %v2float %966 %967 + %969 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %970 = OpLoad %float %969 + %971 = OpCompositeExtract %float %921 1 + %972 = OpCompositeExtract %float %921 0 + %973 = OpCompositeConstruct %v2float %971 %972 + %974 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %975 = OpLoad %float %974 %976 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %977 = OpLoad %float %976 - %978 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %978 %float_0 - %979 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %979 %977 - %980 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %980 - %982 = OpFOrdGreaterThan %bool %972 %float_0_25 - OpSelectionMerge %983 None - OpBranchConditional %982 %984 %983 - %984 = OpLabel - %985 = OpLoad %int %i_2 - OpStore %i_2 %int_0 - OpStore %i_2 %985 - %986 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - %987 = OpLoad %int %986 - %988 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - OpStore %988 %int_0 - %989 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - OpStore %989 %987 - %990 = OpCompositeExtract %float %168 1 - %991 = OpCompositeExtract %float %912 1 - %992 = OpCompositeExtract %float %912 1 - %993 = OpCompositeConstruct %v3float %990 %991 %992 + OpStore %976 %950 + %977 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %977 %975 + %978 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %978 + %980 = OpFOrdGreaterThan %bool %970 %float_0_25 + OpSelectionMerge %981 None + OpBranchConditional %980 %982 %981 + %982 = OpLabel + %983 = OpLoad %int %i_2 + OpStore %i_2 %31 + OpStore %i_2 %983 + %984 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + %985 = OpLoad %int %984 + %986 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + OpStore %986 %31 + %987 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + OpStore %987 %985 + %988 = OpCompositeExtract %float %167 1 + %989 = OpCompositeExtract %float %909 1 + %990 = OpCompositeExtract %float %909 1 + %991 = OpCompositeConstruct %v3float %988 %989 %990 + %992 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %993 = OpLoad %float %992 %994 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %995 = OpLoad %float %994 - %996 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %996 %float_0 - %997 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %997 %995 - %998 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_1 - %999 = OpLoad %int %998 - %1000 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %1000 - %1001 = OpCompositeExtract %float %970 0 - %1002 = OpCompositeExtract %float %970 0 - %1003 = OpCompositeConstruct %v2float %1001 %1002 - %1004 = OpLoad %v2float %uv - OpStore %uv %876 - OpStore %uv %1004 - %1005 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %1005 - %1006 = OpCompositeExtract %float %38 2 - %1007 = OpCompositeExtract %float %168 1 - %1008 = OpCompositeConstruct %v2float %1006 %1007 - %1009 = OpLoad %int %i_2 - OpStore %i_2 %int_0 - OpStore %i_2 %1009 - %1010 = OpAccessChain %_ptr_Function_float %color %int_0 + OpStore %994 %950 + %995 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %995 %993 + %996 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_1 + %997 = OpLoad %int %996 + %998 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %998 + %999 = OpCompositeExtract %float %968 0 + %1000 = OpCompositeExtract %float %968 0 + %1001 = OpCompositeConstruct %v2float %999 %1000 + %1002 = OpLoad %v2float %uv + OpStore %uv %167 + OpStore %uv %1002 + %1003 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %1003 + %1004 = OpCompositeExtract %float %37 2 + %1005 = OpCompositeExtract %float %167 1 + %1006 = OpCompositeConstruct %v2float %1004 %1005 + %1007 = OpLoad %int %i_2 + OpStore %i_2 %31 + OpStore %i_2 %1007 + %1008 = OpAccessChain %_ptr_Function_float %color %31 + %1009 = OpLoad %float %1008 + %1010 = OpAccessChain %_ptr_Function_float %color %31 %1011 = OpLoad %float %1010 - %1012 = OpAccessChain %_ptr_Function_float %color %int_0 - %1013 = OpLoad %float %1012 - %1014 = OpAccessChain %_ptr_Function_float %color %int_0 - OpStore %1014 %float_0 - %1015 = OpAccessChain %_ptr_Function_float %color %int_0 - OpStore %1015 %1013 - %1016 = OpLoad %v3float %color - OpStore %color %888 - OpStore %color %1016 - %1017 = OpLoad %v3float %color - OpStore %color %888 - OpStore %color %1017 - %1018 = OpCompositeExtract %float %970 1 - %1019 = OpCompositeExtract %float %970 1 - %1020 = OpCompositeExtract %float %904 1 - %1021 = OpCompositeConstruct %v3float %1018 %1019 %1020 - %1022 = OpAccessChain %_ptr_Function_float %color %int_0 - %1023 = OpLoad %float %1022 - %1024 = OpAccessChain %_ptr_Function_float %color %int_0 - OpStore %1024 %float_0 - %1025 = OpAccessChain %_ptr_Function_float %color %int_0 - OpStore %1025 %1023 - %1026 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1027 = OpConvertSToF %float %999 - %1028 = OpFAdd %float %1027 %1011 - OpStore %1026 %1028 - %1029 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - %1030 = OpLoad %int %1029 - %1031 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - OpStore %1031 %int_0 - %1032 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - OpStore %1032 %1030 - OpBranch %983 - %983 = OpLabel + %1012 = OpAccessChain %_ptr_Function_float %color %31 + OpStore %1012 %950 + %1013 = OpAccessChain %_ptr_Function_float %color %31 + OpStore %1013 %1011 + %1014 = OpLoad %v3float %color + OpStore %color %170 + OpStore %color %1014 + %1015 = OpLoad %v3float %color + OpStore %color %170 + OpStore %color %1015 + %1016 = OpCompositeExtract %float %968 1 + %1017 = OpCompositeExtract %float %968 1 + %1018 = OpCompositeExtract %float %901 1 + %1019 = OpCompositeConstruct %v3float %1016 %1017 %1018 + %1020 = OpAccessChain %_ptr_Function_float %color %31 + %1021 = OpLoad %float %1020 + %1022 = OpAccessChain %_ptr_Function_float %color %31 + OpStore %1022 %950 + %1023 = OpAccessChain %_ptr_Function_float %color %31 + OpStore %1023 %1021 + %1024 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1025 = OpConvertSToF %float %997 + %1026 = OpFAdd %float %1025 %1009 + OpStore %1024 %1026 + %1027 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + %1028 = OpLoad %int %1027 + %1029 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + OpStore %1029 %31 + %1030 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + OpStore %1030 %1028 + OpBranch %981 + %981 = OpLabel + %1031 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1032 = OpLoad %float %1031 %1033 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1034 = OpLoad %float %1033 + OpStore %1033 %950 + %1034 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1034 %1032 %1035 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1035 %float_0 - %1036 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1036 %1034 + %1036 = OpLoad %float %1035 %1037 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1038 = OpLoad %float %1037 + OpStore %1037 %950 + %1038 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1038 %1036 %1039 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1039 %float_0 - %1040 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1040 %1038 + %1040 = OpLoad %float %1039 %1041 = OpAccessChain %_ptr_Function_float %uv %uint_0 %1042 = OpLoad %float %1041 %1043 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1044 = OpLoad %float %1043 - %1045 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1045 %float_0 - %1046 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1046 %1044 - %1047 = OpCompositeExtract %float %962 2 - %1048 = OpCompositeExtract %float %962 1 - %1049 = OpCompositeExtract %float %962 1 - %1050 = OpCompositeConstruct %v3float %1047 %1048 %1049 - %1051 = OpLoad %v2float %uv - OpStore %uv %876 - OpStore %uv %1051 + OpStore %1043 %950 + %1044 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1044 %1042 + %1045 = OpCompositeExtract %float %960 2 + %1046 = OpCompositeExtract %float %960 1 + %1047 = OpCompositeExtract %float %960 1 + %1048 = OpCompositeConstruct %v3float %1045 %1046 %1047 + %1049 = OpLoad %v2float %uv + OpStore %uv %167 + OpStore %uv %1049 + %1050 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1051 = OpLoad %float %1050 %1052 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1053 = OpLoad %float %1052 - %1054 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1054 %float_0 - %1055 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1055 %1053 - %1056 = OpCompositeExtract %float %168 1 - %1057 = OpCompositeExtract %float %168 1 - %1058 = OpCompositeConstruct %v2float %1056 %1057 + OpStore %1052 %950 + %1053 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1053 %1051 + %1054 = OpCompositeExtract %float %167 1 + %1055 = OpCompositeExtract %float %167 1 + %1056 = OpCompositeConstruct %v2float %1054 %1055 + %1057 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1058 = OpLoad %float %1057 %1059 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1060 = OpLoad %float %1059 - %1061 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1061 %float_0 - %1062 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1062 %1060 - %1064 = OpFOrdGreaterThan %bool %1042 %float_0_5 - OpSelectionMerge %1065 None - OpBranchConditional %1064 %1066 %1065 - %1066 = OpLabel + OpStore %1059 %950 + %1060 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1060 %1058 + %1062 = OpFOrdGreaterThan %bool %1040 %float_0_5 + OpSelectionMerge %1063 None + OpBranchConditional %1062 %1064 %1063 + %1064 = OpLabel + %1065 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1066 = OpLoad %float %1065 %1067 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1068 = OpLoad %float %1067 - %1069 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1069 %float_0 - %1070 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1070 %1068 - %1071 = OpCompositeExtract %float %896 0 - %1072 = OpCompositeExtract %float %896 0 - %1073 = OpCompositeConstruct %v2float %1071 %1072 + OpStore %1067 %950 + %1068 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1068 %1066 + %1069 = OpCompositeExtract %float %893 0 + %1070 = OpCompositeExtract %float %893 0 + %1071 = OpCompositeConstruct %v2float %1069 %1070 + %1072 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1073 = OpLoad %float %1072 %1074 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1075 = OpLoad %float %1074 + OpStore %1074 %950 + %1075 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1075 %1073 %1076 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1076 %float_0 - %1077 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1077 %1075 + %1077 = OpLoad %float %1076 %1078 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1079 = OpLoad %float %1078 - %1080 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1080 %float_0 - %1081 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1081 %1079 - %1082 = OpCompositeExtract %float %962 0 - %1083 = OpCompositeExtract %float %962 2 - %1084 = OpCompositeExtract %float %1058 1 - %1085 = OpCompositeConstruct %v3float %1082 %1083 %1084 + OpStore %1078 %950 + %1079 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1079 %1077 + %1080 = OpCompositeExtract %float %960 0 + %1081 = OpCompositeExtract %float %960 2 + %1082 = OpCompositeExtract %float %1056 1 + %1083 = OpCompositeConstruct %v3float %1080 %1081 %1082 + %1084 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1085 = OpLoad %float %1084 %1086 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1087 = OpLoad %float %1086 - %1088 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1088 %float_0 - %1089 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1089 %1087 - %1091 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_2 - %1092 = OpLoad %int %1091 + OpStore %1086 %950 + %1087 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1087 %1085 + %1089 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_2 + %1090 = OpLoad %int %1089 + %1091 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1092 = OpLoad %float %1091 %1093 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1094 = OpLoad %float %1093 - %1095 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1095 %float_0 - %1096 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1096 %1094 + OpStore %1093 %950 + %1094 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1094 %1092 + %1095 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1096 = OpLoad %float %1095 %1097 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1098 = OpLoad %float %1097 - %1099 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1099 %float_0 - %1100 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1100 %1098 + OpStore %1097 %950 + %1098 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1098 %1096 + %1099 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_2 + %1100 = OpLoad %int %1099 %1101 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_2 - %1102 = OpLoad %int %1101 - %1103 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_2 - OpStore %1103 %int_0 - %1104 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_2 - OpStore %1104 %1102 - %1105 = OpCompositeExtract %float %928 1 - %1106 = OpCompositeExtract %float %917 0 - %1107 = OpCompositeConstruct %v2float %1105 %1106 + OpStore %1101 %31 + %1102 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_2 + OpStore %1102 %1100 + %1103 = OpCompositeExtract %float %925 1 + %1104 = OpCompositeExtract %float %914 0 + %1105 = OpCompositeConstruct %v2float %1103 %1104 + %1106 = OpAccessChain %_ptr_Function_float %color %uint_1 + %1107 = OpLoad %float %1106 %1108 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1109 = OpLoad %float %1108 + OpStore %1108 %950 + %1109 = OpAccessChain %_ptr_Function_float %color %uint_1 + OpStore %1109 %1107 %1110 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1110 %float_0 - %1111 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1111 %1109 - %1112 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1113 = OpLoad %float %1112 + %1111 = OpLoad %float %1110 + %1112 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_2 + %1113 = OpLoad %int %1112 %1114 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_2 - %1115 = OpLoad %int %1114 - %1116 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_2 - OpStore %1116 %int_0 - %1117 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_2 - OpStore %1117 %1115 - %1118 = OpCompositeExtract %float %1085 0 - %1119 = OpCompositeExtract %float %908 0 - %1120 = OpCompositeConstruct %v2float %1118 %1119 + OpStore %1114 %31 + %1115 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_2 + OpStore %1115 %1113 + %1116 = OpCompositeExtract %float %1083 0 + %1117 = OpCompositeExtract %float %905 0 + %1118 = OpCompositeConstruct %v2float %1116 %1117 + %1119 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1120 = OpLoad %float %1119 %1121 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1122 = OpLoad %float %1121 - %1123 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1123 %float_0 - %1124 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1124 %1122 - %1125 = OpLoad %int %i_2 - OpStore %i_2 %int_0 - OpStore %i_2 %1125 - %1126 = OpCompositeExtract %float %975 1 - %1127 = OpCompositeExtract %float %168 1 - %1128 = OpCompositeConstruct %v2float %1126 %1127 - %1129 = OpLoad %int %i_2 - OpStore %i_2 %int_0 - OpStore %i_2 %1129 - %1130 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1131 = OpConvertSToF %float %1092 - %1132 = OpFAdd %float %1131 %1113 - OpStore %1130 %1132 + OpStore %1121 %950 + %1122 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1122 %1120 + %1123 = OpLoad %int %i_2 + OpStore %i_2 %31 + OpStore %i_2 %1123 + %1124 = OpCompositeExtract %float %973 1 + %1125 = OpCompositeExtract %float %167 1 + %1126 = OpCompositeConstruct %v2float %1124 %1125 + %1127 = OpLoad %int %i_2 + OpStore %i_2 %31 + OpStore %i_2 %1127 + %1128 = OpAccessChain %_ptr_Function_float %color %uint_1 + %1129 = OpConvertSToF %float %1090 + %1130 = OpFAdd %float %1129 %1111 + OpStore %1128 %1130 + %1131 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1132 = OpLoad %float %1131 %1133 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1134 = OpLoad %float %1133 - %1135 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1135 %float_0 - %1136 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1136 %1134 - OpBranch %1065 - %1065 = OpLabel - %1137 = OpLoad %int %i_2 - OpStore %i_2 %int_0 - OpStore %i_2 %1137 - %1138 = OpCompositeExtract %float %917 0 - %1139 = OpCompositeExtract %float %917 0 - %1140 = OpCompositeConstruct %v2float %1138 %1139 + OpStore %1133 %950 + %1134 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1134 %1132 + OpBranch %1063 + %1063 = OpLabel + %1135 = OpLoad %int %i_2 + OpStore %i_2 %31 + OpStore %i_2 %1135 + %1136 = OpCompositeExtract %float %914 0 + %1137 = OpCompositeExtract %float %914 0 + %1138 = OpCompositeConstruct %v2float %1136 %1137 + %1139 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1140 = OpLoad %float %1139 %1141 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1142 = OpLoad %float %1141 - %1143 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1143 %float_0 - %1144 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1144 %1142 - %1145 = OpAccessChain %_ptr_Function_float %uv %int_0 - %1146 = OpLoad %float %1145 - %1147 = OpLoad %v3float %color - OpStore %color %888 - OpStore %color %1147 + OpStore %1141 %950 + %1142 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1142 %1140 + %1143 = OpAccessChain %_ptr_Function_float %uv %31 + %1144 = OpLoad %float %1143 + %1145 = OpLoad %v3float %color + OpStore %color %170 + OpStore %color %1145 + %1146 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1147 = OpLoad %float %1146 %1148 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1149 = OpLoad %float %1148 - %1150 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1150 %float_0 - %1151 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1151 %1149 - %1153 = OpFOrdGreaterThan %bool %1146 %float_0_75 - OpSelectionMerge %1154 None - OpBranchConditional %1153 %1155 %1154 - %1155 = OpLabel + OpStore %1148 %950 + %1149 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1149 %1147 + %1151 = OpFOrdGreaterThan %bool %1144 %float_0_75 + OpSelectionMerge %1152 None + OpBranchConditional %1151 %1153 %1152 + %1153 = OpLabel + %1154 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1155 = OpLoad %float %1154 %1156 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1157 = OpLoad %float %1156 - %1158 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1158 %float_0 - %1159 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1159 %1157 - %1161 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_3 - %1162 = OpLoad %int %1161 + OpStore %1156 %950 + %1157 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1157 %1155 + %1159 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_3 + %1160 = OpLoad %int %1159 + %1161 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1162 = OpLoad %float %1161 %1163 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1164 = OpLoad %float %1163 - %1165 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1165 %float_0 - %1166 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1166 %1164 - %1167 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %1167 - %1168 = OpCompositeExtract %float %1140 0 - %1169 = OpCompositeExtract %float %1140 0 - %1170 = OpCompositeExtract %float %1140 0 - %1171 = OpCompositeConstruct %v3float %1168 %1169 %1170 - %1172 = OpAccessChain %_ptr_Function_float %uv %int_0 - %1173 = OpLoad %float %1172 - %1174 = OpAccessChain %_ptr_Function_float %uv %int_0 - OpStore %1174 %float_0 - %1175 = OpAccessChain %_ptr_Function_float %uv %int_0 - OpStore %1175 %1173 + OpStore %1163 %950 + %1164 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1164 %1162 + %1165 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %1165 + %1166 = OpCompositeExtract %float %1138 0 + %1167 = OpCompositeExtract %float %1138 0 + %1168 = OpCompositeExtract %float %1138 0 + %1169 = OpCompositeConstruct %v3float %1166 %1167 %1168 + %1170 = OpAccessChain %_ptr_Function_float %uv %31 + %1171 = OpLoad %float %1170 + %1172 = OpAccessChain %_ptr_Function_float %uv %31 + OpStore %1172 %950 + %1173 = OpAccessChain %_ptr_Function_float %uv %31 + OpStore %1173 %1171 + %1174 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1175 = OpLoad %float %1174 %1176 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1177 = OpLoad %float %1176 - %1178 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1178 %float_0 - %1179 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1179 %1177 - %1180 = OpAccessChain %_ptr_Function_float %color %uint_2 - %1181 = OpLoad %float %1180 - %1182 = OpLoad %v3float %color - OpStore %color %888 - OpStore %color %1182 - %1183 = OpCompositeExtract %float %1140 0 - %1184 = OpCompositeExtract %float %917 1 - %1185 = OpCompositeExtract %float %1140 1 - %1186 = OpCompositeConstruct %v3float %1183 %1184 %1185 + OpStore %1176 %950 + %1177 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1177 %1175 + %1178 = OpAccessChain %_ptr_Function_float %color %uint_2 + %1179 = OpLoad %float %1178 + %1180 = OpLoad %v3float %color + OpStore %color %170 + OpStore %color %1180 + %1181 = OpCompositeExtract %float %1138 0 + %1182 = OpCompositeExtract %float %914 1 + %1183 = OpCompositeExtract %float %1138 1 + %1184 = OpCompositeConstruct %v3float %1181 %1182 %1183 + %1185 = OpAccessChain %_ptr_Function_float %color %uint_2 + %1186 = OpLoad %float %1185 %1187 = OpAccessChain %_ptr_Function_float %color %uint_2 - %1188 = OpLoad %float %1187 - %1189 = OpAccessChain %_ptr_Function_float %color %uint_2 - OpStore %1189 %float_0 - %1190 = OpAccessChain %_ptr_Function_float %color %uint_2 - OpStore %1190 %1188 - %1191 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - %1192 = OpLoad %int %1191 - %1193 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - OpStore %1193 %int_0 - %1194 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - OpStore %1194 %1192 - %1195 = OpCompositeExtract %float %168 0 - %1196 = OpCompositeExtract %float %168 1 - %1197 = OpCompositeConstruct %v2float %1195 %1196 + OpStore %1187 %950 + %1188 = OpAccessChain %_ptr_Function_float %color %uint_2 + OpStore %1188 %1186 + %1189 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + %1190 = OpLoad %int %1189 + %1191 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + OpStore %1191 %31 + %1192 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + OpStore %1192 %1190 + %1193 = OpCompositeExtract %float %167 0 + %1194 = OpCompositeExtract %float %167 1 + %1195 = OpCompositeConstruct %v2float %1193 %1194 + %1196 = OpAccessChain %_ptr_Function_float %color %uint_2 + %1197 = OpLoad %float %1196 %1198 = OpAccessChain %_ptr_Function_float %color %uint_2 - %1199 = OpLoad %float %1198 + OpStore %1198 %950 + %1199 = OpAccessChain %_ptr_Function_float %color %uint_2 + OpStore %1199 %1197 %1200 = OpAccessChain %_ptr_Function_float %color %uint_2 - OpStore %1200 %float_0 - %1201 = OpAccessChain %_ptr_Function_float %color %uint_2 - OpStore %1201 %1199 - %1202 = OpAccessChain %_ptr_Function_float %color %uint_2 - %1203 = OpConvertSToF %float %1162 - %1204 = OpFAdd %float %1181 %1203 - OpStore %1202 %1204 - %1205 = OpLoad %v2float %uv - OpStore %uv %876 - OpStore %uv %1205 - %1206 = OpCompositeExtract %float %1197 1 - %1207 = OpCompositeExtract %float %1197 1 - %1208 = OpCompositeConstruct %v2float %1206 %1207 - OpBranch %1154 - %1154 = OpLabel - %1209 = OpAccessChain %_ptr_Function_float %uv %int_0 - %1210 = OpLoad %float %1209 - %1211 = OpAccessChain %_ptr_Function_float %uv %int_0 - OpStore %1211 %float_0 - %1212 = OpAccessChain %_ptr_Function_float %uv %int_0 - OpStore %1212 %1210 - %1213 = OpCompositeExtract %float %970 0 - %1214 = OpCompositeExtract %float %970 1 - %1215 = OpCompositeExtract %float %970 1 - %1216 = OpCompositeConstruct %v3float %1213 %1214 %1215 - %1218 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - %1219 = OpLoad %int %1218 - %1220 = OpAccessChain %_ptr_Function_float %uv %int_0 - %1221 = OpLoad %float %1220 - %1222 = OpAccessChain %_ptr_Function_float %uv %int_0 - OpStore %1222 %float_0 - %1223 = OpAccessChain %_ptr_Function_float %uv %int_0 - OpStore %1223 %1221 - %1224 = OpLoad %v3float %color - OpStore %color %888 - OpStore %color %1224 - %1225 = OpCompositeExtract %float %896 1 - %1226 = OpCompositeExtract %float %962 0 - %1227 = OpCompositeExtract %float %962 0 - %1228 = OpCompositeConstruct %v3float %1225 %1226 %1227 + %1201 = OpConvertSToF %float %1160 + %1202 = OpFAdd %float %1179 %1201 + OpStore %1200 %1202 + %1203 = OpLoad %v2float %uv + OpStore %uv %167 + OpStore %uv %1203 + %1204 = OpCompositeExtract %float %1195 1 + %1205 = OpCompositeExtract %float %1195 1 + %1206 = OpCompositeConstruct %v2float %1204 %1205 + OpBranch %1152 + %1152 = OpLabel + %1207 = OpAccessChain %_ptr_Function_float %uv %31 + %1208 = OpLoad %float %1207 + %1209 = OpAccessChain %_ptr_Function_float %uv %31 + OpStore %1209 %950 + %1210 = OpAccessChain %_ptr_Function_float %uv %31 + OpStore %1210 %1208 + %1211 = OpCompositeExtract %float %968 0 + %1212 = OpCompositeExtract %float %968 1 + %1213 = OpCompositeExtract %float %968 1 + %1214 = OpCompositeConstruct %v3float %1211 %1212 %1213 + %1216 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 + %1217 = OpLoad %int %1216 + %1218 = OpAccessChain %_ptr_Function_float %uv %31 + %1219 = OpLoad %float %1218 + %1220 = OpAccessChain %_ptr_Function_float %uv %31 + OpStore %1220 %950 + %1221 = OpAccessChain %_ptr_Function_float %uv %31 + OpStore %1221 %1219 + %1222 = OpLoad %v3float %color + OpStore %color %170 + OpStore %color %1222 + %1223 = OpCompositeExtract %float %893 1 + %1224 = OpCompositeExtract %float %960 0 + %1225 = OpCompositeExtract %float %960 0 + %1226 = OpCompositeConstruct %v3float %1223 %1224 %1225 + %1227 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 + %1228 = OpLoad %int %1227 %1229 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - %1230 = OpLoad %int %1229 - %1231 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - OpStore %1231 %int_0 - %1232 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - OpStore %1232 %1230 - %1233 = OpCompositeExtract %float %917 0 - %1234 = OpCompositeExtract %float %900 2 - %1235 = OpCompositeConstruct %v2float %1233 %1234 + OpStore %1229 %31 + %1230 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 + OpStore %1230 %1228 + %1231 = OpCompositeExtract %float %914 0 + %1232 = OpCompositeExtract %float %897 2 + %1233 = OpCompositeConstruct %v2float %1231 %1232 + %1234 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1235 = OpLoad %float %1234 %1236 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1237 = OpLoad %float %1236 - %1238 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1238 %float_0 - %1239 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1239 %1237 + OpStore %1236 %950 + %1237 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1237 %1235 + %1238 = OpAccessChain %_ptr_Function_float %color %uint_1 + %1239 = OpLoad %float %1238 %1240 = OpAccessChain %_ptr_Function_float %color %uint_1 %1241 = OpLoad %float %1240 %1242 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1243 = OpLoad %float %1242 - %1244 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1244 %float_0 - %1245 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1245 %1243 - %1246 = OpCompositeExtract %float %1140 0 - %1247 = OpCompositeExtract %float %928 0 - %1248 = OpCompositeConstruct %v2float %1246 %1247 + OpStore %1242 %950 + %1243 = OpAccessChain %_ptr_Function_float %color %uint_1 + OpStore %1243 %1241 + %1244 = OpCompositeExtract %float %1138 0 + %1245 = OpCompositeExtract %float %925 0 + %1246 = OpCompositeConstruct %v2float %1244 %1245 + %1247 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1248 = OpLoad %float %1247 %1249 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1250 = OpLoad %float %1249 - %1251 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1251 %float_0 - %1252 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1252 %1250 + OpStore %1249 %950 + %1250 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1250 %1248 + %1251 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1252 = OpLoad %float %1251 %1253 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1254 = OpLoad %float %1253 - %1255 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1255 %float_0 - %1256 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1256 %1254 - %1257 = OpCompositeExtract %float %935 2 - %1258 = OpCompositeExtract %float %1050 1 - %1259 = OpCompositeConstruct %v2float %1257 %1258 - %1260 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1261 = OpConvertSToF %float %1219 - %1262 = OpFAdd %float %1241 %1261 - OpStore %1260 %1262 - %1263 = OpCompositeExtract %float %168 0 - %1264 = OpCompositeExtract %float %1216 0 - %1265 = OpCompositeExtract %float %168 1 - %1266 = OpCompositeConstruct %v3float %1263 %1264 %1265 + OpStore %1253 %950 + %1254 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1254 %1252 + %1255 = OpCompositeExtract %float %932 2 + %1256 = OpCompositeExtract %float %1048 1 + %1257 = OpCompositeConstruct %v2float %1255 %1256 + %1258 = OpAccessChain %_ptr_Function_float %color %uint_1 + %1259 = OpConvertSToF %float %1217 + %1260 = OpFAdd %float %1239 %1259 + OpStore %1258 %1260 + %1261 = OpCompositeExtract %float %167 0 + %1262 = OpCompositeExtract %float %1214 0 + %1263 = OpCompositeExtract %float %167 1 + %1264 = OpCompositeConstruct %v3float %1261 %1262 %1263 + %1265 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1266 = OpLoad %float %1265 %1267 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1268 = OpLoad %float %1267 - %1269 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1269 %float_0 - %1270 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1270 %1268 + OpStore %1267 %950 + %1268 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1268 %1266 + %1269 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1270 = OpLoad %float %1269 %1271 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1272 = OpLoad %float %1271 - %1273 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1273 %float_0 - %1274 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1274 %1272 - %1275 = OpCompositeExtract %float %1216 0 - %1276 = OpCompositeExtract %float %1216 1 - %1277 = OpCompositeConstruct %v2float %1275 %1276 + OpStore %1271 %950 + %1272 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1272 %1270 + %1273 = OpCompositeExtract %float %1214 0 + %1274 = OpCompositeExtract %float %1214 1 + %1275 = OpCompositeConstruct %v2float %1273 %1274 + %1276 = OpAccessChain %_ptr_Function_float %uv %uint_1 + %1277 = OpLoad %float %1276 %1278 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1279 = OpLoad %float %1278 + OpStore %1278 %950 + %1279 = OpAccessChain %_ptr_Function_float %uv %uint_1 + OpStore %1279 %1277 %1280 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1280 %float_0 - %1281 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1281 %1279 - %1282 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1283 = OpLoad %float %1282 - %1284 = OpLoad %int %i_2 - OpStore %i_2 %int_0 - OpStore %i_2 %1284 - %1285 = OpCompositeExtract %float %168 1 - %1286 = OpCompositeExtract %float %970 1 - %1287 = OpCompositeExtract %float %168 0 - %1288 = OpCompositeConstruct %v3float %1285 %1286 %1287 - %1289 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - %1290 = OpLoad %int %1289 - %1291 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - OpStore %1291 %int_0 - %1292 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - OpStore %1292 %1290 + %1281 = OpLoad %float %1280 + %1282 = OpLoad %int %i_2 + OpStore %i_2 %31 + OpStore %i_2 %1282 + %1283 = OpCompositeExtract %float %167 1 + %1284 = OpCompositeExtract %float %968 1 + %1285 = OpCompositeExtract %float %167 0 + %1286 = OpCompositeConstruct %v3float %1283 %1284 %1285 + %1287 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + %1288 = OpLoad %int %1287 + %1289 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + OpStore %1289 %31 + %1290 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + OpStore %1290 %1288 + %1291 = OpAccessChain %_ptr_Function_float %color %uint_1 + %1292 = OpLoad %float %1291 %1293 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1294 = OpLoad %float %1293 - %1295 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1295 %float_0 - %1296 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1296 %1294 - %1297 = OpCompositeExtract %float %896 0 - %1298 = OpCompositeExtract %float %896 0 - %1299 = OpCompositeExtract %float %168 1 - %1300 = OpCompositeConstruct %v3float %1297 %1298 %1299 + OpStore %1293 %950 + %1294 = OpAccessChain %_ptr_Function_float %color %uint_1 + OpStore %1294 %1292 + %1295 = OpCompositeExtract %float %893 0 + %1296 = OpCompositeExtract %float %893 0 + %1297 = OpCompositeExtract %float %167 1 + %1298 = OpCompositeConstruct %v3float %1295 %1296 %1297 + %1299 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1300 = OpLoad %float %1299 %1301 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1302 = OpLoad %float %1301 - %1303 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1303 %float_0 - %1304 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1304 %1302 - %1305 = OpFOrdGreaterThan %bool %1283 %float_0_25 - OpSelectionMerge %1306 None - OpBranchConditional %1305 %1307 %1306 - %1307 = OpLabel - %1308 = OpCompositeExtract %float %904 0 - %1309 = OpCompositeExtract %float %1300 2 - %1310 = OpCompositeConstruct %v2float %1308 %1309 - %1311 = OpLoad %v3float %color - OpStore %color %888 - OpStore %color %1311 - %1313 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_5 - %1314 = OpLoad %int %1313 + OpStore %1301 %950 + %1302 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1302 %1300 + %1303 = OpFOrdGreaterThan %bool %1281 %float_0_25 + OpSelectionMerge %1304 None + OpBranchConditional %1303 %1305 %1304 + %1305 = OpLabel + %1306 = OpCompositeExtract %float %901 0 + %1307 = OpCompositeExtract %float %1298 2 + %1308 = OpCompositeConstruct %v2float %1306 %1307 + %1309 = OpLoad %v3float %color + OpStore %color %170 + OpStore %color %1309 + %1311 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_5 + %1312 = OpLoad %int %1311 + %1313 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1314 = OpLoad %float %1313 %1315 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1316 = OpLoad %float %1315 - %1317 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1317 %float_0 - %1318 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1318 %1316 - %1319 = OpLoad %int %i_2 - OpStore %i_2 %int_0 - OpStore %i_2 %1319 - %1320 = OpLoad %int %i_2 - OpStore %i_2 %int_0 - OpStore %i_2 %1320 - %1321 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1315 %950 + %1316 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1316 %1314 + %1317 = OpLoad %int %i_2 + OpStore %i_2 %31 + OpStore %i_2 %1317 + %1318 = OpLoad %int %i_2 + OpStore %i_2 %31 + OpStore %i_2 %1318 + %1319 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1320 = OpLoad %float %1319 + %1321 = OpAccessChain %_ptr_Function_float %uv %31 %1322 = OpLoad %float %1321 - %1323 = OpAccessChain %_ptr_Function_float %uv %int_0 - %1324 = OpLoad %float %1323 - %1325 = OpAccessChain %_ptr_Function_float %uv %int_0 - OpStore %1325 %float_0 - %1326 = OpAccessChain %_ptr_Function_float %uv %int_0 - OpStore %1326 %1324 - %1327 = OpCompositeExtract %float %975 0 - %1328 = OpCompositeExtract %float %1248 1 - %1329 = OpCompositeExtract %float %975 1 - %1330 = OpCompositeConstruct %v3float %1327 %1328 %1329 - %1331 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %1331 + %1323 = OpAccessChain %_ptr_Function_float %uv %31 + OpStore %1323 %950 + %1324 = OpAccessChain %_ptr_Function_float %uv %31 + OpStore %1324 %1322 + %1325 = OpCompositeExtract %float %973 0 + %1326 = OpCompositeExtract %float %1246 1 + %1327 = OpCompositeExtract %float %973 1 + %1328 = OpCompositeConstruct %v3float %1325 %1326 %1327 + %1329 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %1329 + %1330 = OpAccessChain %_ptr_Function_float %uv %uint_1 + %1331 = OpLoad %float %1330 %1332 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1333 = OpLoad %float %1332 - %1334 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1334 %float_0 - %1335 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1335 %1333 - %1336 = OpLoad %int %i_2 - OpStore %i_2 %int_0 - OpStore %i_2 %1336 - %1337 = OpCompositeExtract %float %900 3 - %1338 = OpCompositeExtract %float %900 3 - %1339 = OpCompositeExtract %float %924 0 - %1340 = OpCompositeConstruct %v3float %1337 %1338 %1339 + OpStore %1332 %950 + %1333 = OpAccessChain %_ptr_Function_float %uv %uint_1 + OpStore %1333 %1331 + %1334 = OpLoad %int %i_2 + OpStore %i_2 %31 + OpStore %i_2 %1334 + %1335 = OpCompositeExtract %float %897 3 + %1336 = OpCompositeExtract %float %897 3 + %1337 = OpCompositeExtract %float %921 0 + %1338 = OpCompositeConstruct %v3float %1335 %1336 %1337 + %1339 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1340 = OpLoad %float %1339 %1341 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1342 = OpLoad %float %1341 - %1343 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1343 %float_0 - %1344 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1344 %1342 - %1345 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1346 = OpConvertSToF %float %1314 - %1347 = OpFAdd %float %1346 %1322 - OpStore %1345 %1347 - %1348 = OpCompositeExtract %float %970 1 - %1349 = OpCompositeExtract %float %928 0 - %1350 = OpCompositeExtract %float %970 1 - %1351 = OpCompositeConstruct %v3float %1348 %1349 %1350 + OpStore %1341 %950 + %1342 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1342 %1340 + %1343 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1344 = OpConvertSToF %float %1312 + %1345 = OpFAdd %float %1344 %1320 + OpStore %1343 %1345 + %1346 = OpCompositeExtract %float %968 1 + %1347 = OpCompositeExtract %float %925 0 + %1348 = OpCompositeExtract %float %968 1 + %1349 = OpCompositeConstruct %v3float %1346 %1347 %1348 + %1350 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1351 = OpLoad %float %1350 %1352 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1353 = OpLoad %float %1352 - %1354 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1354 %float_0 - %1355 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1355 %1353 - OpBranch %1306 - %1306 = OpLabel + OpStore %1352 %950 + %1353 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1353 %1351 + OpBranch %1304 + %1304 = OpLabel + %1354 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1355 = OpLoad %float %1354 %1356 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1357 = OpLoad %float %1356 - %1358 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1358 %float_0 - %1359 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1359 %1357 - %1360 = OpCompositeExtract %float %1140 0 - %1361 = OpCompositeExtract %float %928 1 - %1362 = OpCompositeExtract %float %928 0 - %1363 = OpCompositeConstruct %v3float %1360 %1361 %1362 + OpStore %1356 %950 + %1357 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1357 %1355 + %1358 = OpCompositeExtract %float %1138 0 + %1359 = OpCompositeExtract %float %925 1 + %1360 = OpCompositeExtract %float %925 0 + %1361 = OpCompositeConstruct %v3float %1358 %1359 %1360 + %1362 = OpAccessChain %_ptr_Function_float %uv %uint_1 + %1363 = OpLoad %float %1362 %1364 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1365 = OpLoad %float %1364 - %1366 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1366 %float_0 - %1367 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1367 %1365 + OpStore %1364 %950 + %1365 = OpAccessChain %_ptr_Function_float %uv %uint_1 + OpStore %1365 %1363 + %1366 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 + %1367 = OpLoad %int %1366 %1368 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - %1369 = OpLoad %int %1368 - %1370 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - OpStore %1370 %int_0 - %1371 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - OpStore %1371 %1369 - %1372 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1373 = OpLoad %float %1372 - %1374 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - %1375 = OpLoad %int %1374 - %1376 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - OpStore %1376 %int_0 - %1377 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - OpStore %1377 %1375 - %1378 = OpFOrdGreaterThan %bool %1373 %float_0_5 - OpSelectionMerge %1379 None - OpBranchConditional %1378 %1380 %1379 - %1380 = OpLabel + OpStore %1368 %31 + %1369 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 + OpStore %1369 %1367 + %1370 = OpAccessChain %_ptr_Function_float %uv %uint_1 + %1371 = OpLoad %float %1370 + %1372 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + %1373 = OpLoad %int %1372 + %1374 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + OpStore %1374 %31 + %1375 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + OpStore %1375 %1373 + %1376 = OpFOrdGreaterThan %bool %1371 %float_0_5 + OpSelectionMerge %1377 None + OpBranchConditional %1376 %1378 %1377 + %1378 = OpLabel + %1379 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1380 = OpLoad %float %1379 %1381 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1382 = OpLoad %float %1381 - %1383 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1383 %float_0 - %1384 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1384 %1382 - %1385 = OpCompositeExtract %float %1300 1 - %1386 = OpCompositeExtract %float %975 1 - %1387 = OpCompositeConstruct %v2float %1385 %1386 + OpStore %1381 %950 + %1382 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1382 %1380 + %1383 = OpCompositeExtract %float %1298 1 + %1384 = OpCompositeExtract %float %973 1 + %1385 = OpCompositeConstruct %v2float %1383 %1384 + %1386 = OpAccessChain %_ptr_Function_float %color %uint_1 + %1387 = OpLoad %float %1386 %1388 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1389 = OpLoad %float %1388 - %1390 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1390 %float_0 - %1391 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1391 %1389 - %1392 = OpCompositeExtract %float %922 2 - %1393 = OpCompositeExtract %float %922 1 - %1394 = OpCompositeConstruct %v2float %1392 %1393 + OpStore %1388 %950 + %1389 = OpAccessChain %_ptr_Function_float %color %uint_1 + OpStore %1389 %1387 + %1390 = OpCompositeExtract %float %919 2 + %1391 = OpCompositeExtract %float %919 1 + %1392 = OpCompositeConstruct %v2float %1390 %1391 + %1393 = OpAccessChain %_ptr_Function_float %uv %uint_1 + %1394 = OpLoad %float %1393 %1395 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1396 = OpLoad %float %1395 - %1397 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1397 %float_0 - %1398 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1398 %1396 - %1400 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_6 - %1401 = OpLoad %int %1400 + OpStore %1395 %950 + %1396 = OpAccessChain %_ptr_Function_float %uv %uint_1 + OpStore %1396 %1394 + %1398 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_6 + %1399 = OpLoad %int %1398 + %1400 = OpAccessChain %_ptr_Function_float %uv %uint_1 + %1401 = OpLoad %float %1400 %1402 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1403 = OpLoad %float %1402 - %1404 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1404 %float_0 - %1405 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1405 %1403 - %1406 = OpLoad %int %i_2 - OpStore %i_2 %int_0 - OpStore %i_2 %1406 + OpStore %1402 %950 + %1403 = OpAccessChain %_ptr_Function_float %uv %uint_1 + OpStore %1403 %1401 + %1404 = OpLoad %int %i_2 + OpStore %i_2 %31 + OpStore %i_2 %1404 + %1405 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 + %1406 = OpLoad %int %1405 %1407 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - %1408 = OpLoad %int %1407 - %1409 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - OpStore %1409 %int_0 - %1410 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - OpStore %1410 %1408 - %1411 = OpCompositeExtract %float %1228 2 - %1412 = OpCompositeExtract %float %1228 1 - %1413 = OpCompositeConstruct %v2float %1411 %1412 - %1414 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1415 = OpLoad %float %1414 - %1416 = OpLoad %v2float %uv - OpStore %uv %876 - OpStore %uv %1416 + OpStore %1407 %31 + %1408 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 + OpStore %1408 %1406 + %1409 = OpCompositeExtract %float %1226 2 + %1410 = OpCompositeExtract %float %1226 1 + %1411 = OpCompositeConstruct %v2float %1409 %1410 + %1412 = OpAccessChain %_ptr_Function_float %color %uint_1 + %1413 = OpLoad %float %1412 + %1414 = OpLoad %v2float %uv + OpStore %uv %167 + OpStore %uv %1414 + %1415 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1416 = OpLoad %float %1415 %1417 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1418 = OpLoad %float %1417 - %1419 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1419 %float_0 - %1420 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1420 %1418 - %1421 = OpCompositeExtract %float %1248 1 - %1422 = OpCompositeExtract %float %1248 0 - %1423 = OpCompositeConstruct %v2float %1421 %1422 + OpStore %1417 %950 + %1418 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1418 %1416 + %1419 = OpCompositeExtract %float %1246 1 + %1420 = OpCompositeExtract %float %1246 0 + %1421 = OpCompositeConstruct %v2float %1419 %1420 + %1422 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_6 + %1423 = OpLoad %int %1422 %1424 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_6 - %1425 = OpLoad %int %1424 + OpStore %1424 %31 + %1425 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_6 + OpStore %1425 %1423 %1426 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_6 - OpStore %1426 %int_0 - %1427 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_6 - OpStore %1427 %1425 + %1427 = OpLoad %int %1426 %1428 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_6 - %1429 = OpLoad %int %1428 - %1430 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_6 - OpStore %1430 %int_0 - %1431 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_6 - OpStore %1431 %1429 - %1432 = OpCompositeExtract %float %1300 2 - %1433 = OpCompositeExtract %float %1300 2 - %1434 = OpCompositeConstruct %v2float %1432 %1433 - %1435 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %1435 - %1436 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1437 = OpConvertSToF %float %1401 - %1438 = OpFAdd %float %1437 %1415 - OpStore %1436 %1438 + OpStore %1428 %31 + %1429 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_6 + OpStore %1429 %1427 + %1430 = OpCompositeExtract %float %1298 2 + %1431 = OpCompositeExtract %float %1298 2 + %1432 = OpCompositeConstruct %v2float %1430 %1431 + %1433 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %1433 + %1434 = OpAccessChain %_ptr_Function_float %color %uint_1 + %1435 = OpConvertSToF %float %1399 + %1436 = OpFAdd %float %1435 %1413 + OpStore %1434 %1436 + %1437 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1438 = OpLoad %float %1437 %1439 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1440 = OpLoad %float %1439 - %1441 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1441 %float_0 - %1442 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1442 %1440 - %1443 = OpCompositeExtract %float %38 1 - %1444 = OpCompositeExtract %float %970 0 - %1445 = OpCompositeConstruct %v2float %1443 %1444 + OpStore %1439 %950 + %1440 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1440 %1438 + %1441 = OpCompositeExtract %float %37 1 + %1442 = OpCompositeExtract %float %968 0 + %1443 = OpCompositeConstruct %v2float %1441 %1442 + %1444 = OpAccessChain %_ptr_Function_float %color %uint_1 + %1445 = OpLoad %float %1444 %1446 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1447 = OpLoad %float %1446 - %1448 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1448 %float_0 - %1449 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1449 %1447 - OpBranch %1379 - %1379 = OpLabel - %1450 = OpCompositeExtract %float %975 1 - %1451 = OpCompositeExtract %float %975 1 - %1452 = OpCompositeConstruct %v2float %1450 %1451 + OpStore %1446 %950 + %1447 = OpAccessChain %_ptr_Function_float %color %uint_1 + OpStore %1447 %1445 + OpBranch %1377 + %1377 = OpLabel + %1448 = OpCompositeExtract %float %973 1 + %1449 = OpCompositeExtract %float %973 1 + %1450 = OpCompositeConstruct %v2float %1448 %1449 + %1451 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1452 = OpLoad %float %1451 %1453 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1454 = OpLoad %float %1453 - %1455 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1455 %float_0 - %1456 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1456 %1454 - %1457 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1458 = OpLoad %float %1457 - %1459 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %1459 - %1460 = OpCompositeExtract %float %1248 0 - %1461 = OpCompositeExtract %float %1248 1 - %1462 = OpCompositeConstruct %v2float %1460 %1461 - %1463 = OpAccessChain %_ptr_Function_float %uv %int_0 - %1464 = OpLoad %float %1463 - %1465 = OpAccessChain %_ptr_Function_float %uv %int_0 - OpStore %1465 %float_0 - %1466 = OpAccessChain %_ptr_Function_float %uv %int_0 - OpStore %1466 %1464 + OpStore %1453 %950 + %1454 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1454 %1452 + %1455 = OpAccessChain %_ptr_Function_float %uv %uint_1 + %1456 = OpLoad %float %1455 + %1457 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %1457 + %1458 = OpCompositeExtract %float %1246 0 + %1459 = OpCompositeExtract %float %1246 1 + %1460 = OpCompositeConstruct %v2float %1458 %1459 + %1461 = OpAccessChain %_ptr_Function_float %uv %31 + %1462 = OpLoad %float %1461 + %1463 = OpAccessChain %_ptr_Function_float %uv %31 + OpStore %1463 %950 + %1464 = OpAccessChain %_ptr_Function_float %uv %31 + OpStore %1464 %1462 + %1465 = OpAccessChain %_ptr_Function_float %color %uint_1 + %1466 = OpLoad %float %1465 %1467 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1468 = OpLoad %float %1467 - %1469 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1469 %float_0 - %1470 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1470 %1468 - %1471 = OpCompositeExtract %float %917 0 - %1472 = OpCompositeExtract %float %917 1 - %1473 = OpCompositeExtract %float %917 1 - %1474 = OpCompositeConstruct %v3float %1471 %1472 %1473 + OpStore %1467 %950 + %1468 = OpAccessChain %_ptr_Function_float %color %uint_1 + OpStore %1468 %1466 + %1469 = OpCompositeExtract %float %914 0 + %1470 = OpCompositeExtract %float %914 1 + %1471 = OpCompositeExtract %float %914 1 + %1472 = OpCompositeConstruct %v3float %1469 %1470 %1471 + %1473 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 + %1474 = OpLoad %int %1473 %1475 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - %1476 = OpLoad %int %1475 - %1477 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - OpStore %1477 %int_0 - %1478 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - OpStore %1478 %1476 - %1479 = OpFOrdGreaterThan %bool %1458 %float_0_75 - OpSelectionMerge %1480 None - OpBranchConditional %1479 %1481 %1480 - %1481 = OpLabel - %1482 = OpLoad %v3float %color - OpStore %color %888 - OpStore %color %1482 + OpStore %1475 %31 + %1476 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 + OpStore %1476 %1474 + %1477 = OpFOrdGreaterThan %bool %1456 %float_0_75 + OpSelectionMerge %1478 None + OpBranchConditional %1477 %1479 %1478 + %1479 = OpLabel + %1480 = OpLoad %v3float %color + OpStore %color %170 + OpStore %color %1480 + %1481 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1482 = OpLoad %float %1481 %1483 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1484 = OpLoad %float %1483 - %1485 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1485 %float_0 - %1486 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1486 %1484 - %1487 = OpCompositeExtract %float %924 1 - %1488 = OpCompositeExtract %float %924 0 - %1489 = OpCompositeExtract %float %924 1 - %1490 = OpCompositeConstruct %v3float %1487 %1488 %1489 - %1491 = OpLoad %v3float %color - OpStore %color %888 - OpStore %color %1491 - %1493 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_7 - %1494 = OpLoad %int %1493 + OpStore %1483 %950 + %1484 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1484 %1482 + %1485 = OpCompositeExtract %float %921 1 + %1486 = OpCompositeExtract %float %921 0 + %1487 = OpCompositeExtract %float %921 1 + %1488 = OpCompositeConstruct %v3float %1485 %1486 %1487 + %1489 = OpLoad %v3float %color + OpStore %color %170 + OpStore %color %1489 + %1491 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_7 + %1492 = OpLoad %int %1491 + %1493 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1494 = OpLoad %float %1493 %1495 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1496 = OpLoad %float %1495 - %1497 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1497 %float_0 - %1498 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1498 %1496 - %1499 = OpCompositeExtract %float %1248 0 - %1500 = OpCompositeExtract %float %1140 1 - %1501 = OpCompositeExtract %float %1140 0 - %1502 = OpCompositeConstruct %v3float %1499 %1500 %1501 + OpStore %1495 %950 + %1496 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1496 %1494 + %1497 = OpCompositeExtract %float %1246 0 + %1498 = OpCompositeExtract %float %1138 1 + %1499 = OpCompositeExtract %float %1138 0 + %1500 = OpCompositeConstruct %v3float %1497 %1498 %1499 + %1501 = OpAccessChain %_ptr_Function_float %color %uint_1 + %1502 = OpLoad %float %1501 %1503 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1504 = OpLoad %float %1503 - %1505 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1505 %float_0 - %1506 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1506 %1504 - %1507 = OpCompositeExtract %float %1266 0 - %1508 = OpCompositeExtract %float %1058 1 - %1509 = OpCompositeConstruct %v2float %1507 %1508 - %1510 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - %1511 = OpLoad %int %1510 - %1512 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - OpStore %1512 %int_0 - %1513 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_0 - OpStore %1513 %1511 + OpStore %1503 %950 + %1504 = OpAccessChain %_ptr_Function_float %color %uint_1 + OpStore %1504 %1502 + %1505 = OpCompositeExtract %float %1264 0 + %1506 = OpCompositeExtract %float %1056 1 + %1507 = OpCompositeConstruct %v2float %1505 %1506 + %1508 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + %1509 = OpLoad %int %1508 + %1510 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + OpStore %1510 %31 + %1511 = OpAccessChain %_ptr_Private_int %obj %uint_0 %521 + OpStore %1511 %1509 + %1512 = OpAccessChain %_ptr_Function_float %color %uint_1 + %1513 = OpLoad %float %1512 %1514 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1515 = OpLoad %float %1514 - %1516 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1516 %float_0 - %1517 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1517 %1515 - %1518 = OpCompositeExtract %float %1277 0 - %1519 = OpCompositeExtract %float %1277 1 - %1520 = OpCompositeExtract %float %1277 0 - %1521 = OpCompositeConstruct %v3float %1518 %1519 %1520 + OpStore %1514 %950 + %1515 = OpAccessChain %_ptr_Function_float %color %uint_1 + OpStore %1515 %1513 + %1516 = OpCompositeExtract %float %1275 0 + %1517 = OpCompositeExtract %float %1275 1 + %1518 = OpCompositeExtract %float %1275 0 + %1519 = OpCompositeConstruct %v3float %1516 %1517 %1518 + %1520 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1521 = OpLoad %float %1520 %1522 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1523 = OpLoad %float %1522 - %1524 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1524 %float_0 - %1525 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1525 %1523 - %1526 = OpAccessChain %_ptr_Function_float %color %uint_2 + OpStore %1522 %950 + %1523 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1523 %1521 + %1524 = OpAccessChain %_ptr_Function_float %color %uint_2 + %1525 = OpLoad %float %1524 + %1526 = OpAccessChain %_ptr_Function_float %uv %uint_1 %1527 = OpLoad %float %1526 %1528 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1529 = OpLoad %float %1528 - %1530 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1530 %float_0 - %1531 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1531 %1529 - %1532 = OpCompositeExtract %float %900 0 - %1533 = OpCompositeExtract %float %900 1 - %1534 = OpCompositeConstruct %v2float %1532 %1533 + OpStore %1528 %950 + %1529 = OpAccessChain %_ptr_Function_float %uv %uint_1 + OpStore %1529 %1527 + %1530 = OpCompositeExtract %float %897 0 + %1531 = OpCompositeExtract %float %897 1 + %1532 = OpCompositeConstruct %v2float %1530 %1531 + %1533 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1534 = OpLoad %float %1533 %1535 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1536 = OpLoad %float %1535 - %1537 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1537 %float_0 - %1538 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1538 %1536 + OpStore %1535 %950 + %1536 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1536 %1534 + %1537 = OpAccessChain %_ptr_Function_float %uv %uint_1 + %1538 = OpLoad %float %1537 %1539 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1540 = OpLoad %float %1539 + OpStore %1539 %950 + %1540 = OpAccessChain %_ptr_Function_float %uv %uint_1 + OpStore %1540 %1538 %1541 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1541 %float_0 - %1542 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1542 %1540 + %1542 = OpLoad %float %1541 %1543 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1544 = OpLoad %float %1543 - %1545 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1545 %float_0 - %1546 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1546 %1544 - %1547 = OpCompositeExtract %float %1534 1 - %1548 = OpCompositeExtract %float %1534 1 - %1549 = OpCompositeExtract %float %1474 2 - %1550 = OpCompositeConstruct %v3float %1547 %1548 %1549 + OpStore %1543 %950 + %1544 = OpAccessChain %_ptr_Function_float %uv %uint_1 + OpStore %1544 %1542 + %1545 = OpCompositeExtract %float %1532 1 + %1546 = OpCompositeExtract %float %1532 1 + %1547 = OpCompositeExtract %float %1472 2 + %1548 = OpCompositeConstruct %v3float %1545 %1546 %1547 + %1549 = OpAccessChain %_ptr_Function_float %color %uint_2 + %1550 = OpLoad %float %1549 %1551 = OpAccessChain %_ptr_Function_float %color %uint_2 - %1552 = OpLoad %float %1551 + OpStore %1551 %950 + %1552 = OpAccessChain %_ptr_Function_float %color %uint_2 + OpStore %1552 %1550 %1553 = OpAccessChain %_ptr_Function_float %color %uint_2 - OpStore %1553 %float_0 - %1554 = OpAccessChain %_ptr_Function_float %color %uint_2 - OpStore %1554 %1552 - %1555 = OpAccessChain %_ptr_Function_float %color %uint_2 - %1556 = OpConvertSToF %float %1494 - %1557 = OpFAdd %float %1556 %1527 - OpStore %1555 %1557 + %1554 = OpConvertSToF %float %1492 + %1555 = OpFAdd %float %1554 %1525 + OpStore %1553 %1555 + %1556 = OpAccessChain %_ptr_Function_float %color %uint_1 + %1557 = OpLoad %float %1556 %1558 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1559 = OpLoad %float %1558 - %1560 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1560 %float_0 - %1561 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1561 %1559 - %1562 = OpCompositeExtract %float %962 0 - %1563 = OpCompositeExtract %float %962 2 - %1564 = OpCompositeConstruct %v2float %1562 %1563 + OpStore %1558 %950 + %1559 = OpAccessChain %_ptr_Function_float %color %uint_1 + OpStore %1559 %1557 + %1560 = OpCompositeExtract %float %960 0 + %1561 = OpCompositeExtract %float %960 2 + %1562 = OpCompositeConstruct %v2float %1560 %1561 + %1563 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1564 = OpLoad %float %1563 %1565 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1566 = OpLoad %float %1565 - %1567 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1567 %float_0 - %1568 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1568 %1566 - OpBranch %1480 - %1480 = OpLabel - %1569 = OpLoad %int %i_2 - OpStore %i_2 %int_0 - OpStore %i_2 %1569 - %1570 = OpCompositeExtract %float %935 1 - %1571 = OpCompositeExtract %float %924 1 - %1572 = OpCompositeConstruct %v2float %1570 %1571 - %1573 = OpLoad %v2float %uv - OpStore %uv %876 - OpStore %uv %1573 - %1575 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_8 - %1576 = OpLoad %int %1575 - %1577 = OpLoad %int %i_2 - OpStore %i_2 %int_0 - OpStore %i_2 %1577 - %1578 = OpCompositeExtract %float %908 0 - %1579 = OpCompositeExtract %float %935 2 - %1580 = OpCompositeConstruct %v2float %1578 %1579 + OpStore %1565 %950 + %1566 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1566 %1564 + OpBranch %1478 + %1478 = OpLabel + %1567 = OpLoad %int %i_2 + OpStore %i_2 %31 + OpStore %i_2 %1567 + %1568 = OpCompositeExtract %float %932 1 + %1569 = OpCompositeExtract %float %921 1 + %1570 = OpCompositeConstruct %v2float %1568 %1569 + %1571 = OpLoad %v2float %uv + OpStore %uv %167 + OpStore %uv %1571 + %1573 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_8 + %1574 = OpLoad %int %1573 + %1575 = OpLoad %int %i_2 + OpStore %i_2 %31 + OpStore %i_2 %1575 + %1576 = OpCompositeExtract %float %905 0 + %1577 = OpCompositeExtract %float %932 2 + %1578 = OpCompositeConstruct %v2float %1576 %1577 + %1579 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_8 + %1580 = OpLoad %int %1579 %1581 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_8 - %1582 = OpLoad %int %1581 - %1583 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_8 - OpStore %1583 %int_0 - %1584 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_8 - OpStore %1584 %1582 + OpStore %1581 %31 + %1582 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_8 + OpStore %1582 %1580 + %1583 = OpAccessChain %_ptr_Function_float %color %uint_1 + %1584 = OpLoad %float %1583 %1585 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1586 = OpLoad %float %1585 - %1587 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1587 %float_0 - %1588 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1588 %1586 - %1589 = OpCompositeExtract %float %962 1 - %1590 = OpCompositeExtract %float %168 0 - %1591 = OpCompositeConstruct %v2float %1589 %1590 + OpStore %1585 %950 + %1586 = OpAccessChain %_ptr_Function_float %color %uint_1 + OpStore %1586 %1584 + %1587 = OpCompositeExtract %float %960 1 + %1588 = OpCompositeExtract %float %167 0 + %1589 = OpCompositeConstruct %v2float %1587 %1588 + %1590 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1591 = OpLoad %float %1590 %1592 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1593 = OpLoad %float %1592 - %1594 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1594 %float_0 - %1595 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1595 %1593 - %1596 = OpCompositeExtract %float %1591 0 - %1597 = OpCompositeExtract %float %1591 1 - %1598 = OpCompositeExtract %float %1591 0 - %1599 = OpCompositeConstruct %v3float %1596 %1597 %1598 + OpStore %1592 %950 + %1593 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1593 %1591 + %1594 = OpCompositeExtract %float %1589 0 + %1595 = OpCompositeExtract %float %1589 1 + %1596 = OpCompositeExtract %float %1589 0 + %1597 = OpCompositeConstruct %v3float %1594 %1595 %1596 + %1598 = OpAccessChain %_ptr_Function_float %color %uint_2 + %1599 = OpLoad %float %1598 %1600 = OpAccessChain %_ptr_Function_float %color %uint_2 - %1601 = OpLoad %float %1600 + OpStore %1600 %950 + %1601 = OpAccessChain %_ptr_Function_float %color %uint_2 + OpStore %1601 %1599 %1602 = OpAccessChain %_ptr_Function_float %color %uint_2 - OpStore %1602 %float_0 - %1603 = OpAccessChain %_ptr_Function_float %color %uint_2 - OpStore %1603 %1601 - %1604 = OpAccessChain %_ptr_Function_float %color %uint_2 + %1603 = OpLoad %float %1602 + %1604 = OpAccessChain %_ptr_Function_float %color %uint_0 %1605 = OpLoad %float %1604 %1606 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1607 = OpLoad %float %1606 - %1608 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1608 %float_0 - %1609 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1609 %1607 - %1610 = OpCompositeExtract %float %1462 0 - %1611 = OpCompositeExtract %float %1452 0 - %1612 = OpCompositeConstruct %v2float %1610 %1611 + OpStore %1606 %950 + %1607 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1607 %1605 + %1608 = OpCompositeExtract %float %1460 0 + %1609 = OpCompositeExtract %float %1450 0 + %1610 = OpCompositeConstruct %v2float %1608 %1609 + %1611 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 + %1612 = OpLoad %int %1611 %1613 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - %1614 = OpLoad %int %1613 - %1615 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - OpStore %1615 %int_0 - %1616 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - OpStore %1616 %1614 + OpStore %1613 %31 + %1614 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 + OpStore %1614 %1612 + %1615 = OpAccessChain %_ptr_Function_float %uv %uint_1 + %1616 = OpLoad %float %1615 %1617 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1618 = OpLoad %float %1617 - %1619 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1619 %float_0 - %1620 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1620 %1618 - %1621 = OpCompositeExtract %float %1058 0 - %1622 = OpCompositeExtract %float %904 0 - %1623 = OpCompositeConstruct %v2float %1621 %1622 + OpStore %1617 %950 + %1618 = OpAccessChain %_ptr_Function_float %uv %uint_1 + OpStore %1618 %1616 + %1619 = OpCompositeExtract %float %1056 0 + %1620 = OpCompositeExtract %float %901 0 + %1621 = OpCompositeConstruct %v2float %1619 %1620 + %1622 = OpAccessChain %_ptr_Function_float %color %uint_1 + %1623 = OpLoad %float %1622 %1624 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1625 = OpLoad %float %1624 - %1626 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1626 %float_0 - %1627 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1627 %1625 - %1628 = OpAccessChain %_ptr_Function_float %color %uint_2 - %1629 = OpConvertSToF %float %1576 - %1630 = OpFAdd %float %1605 %1629 - OpStore %1628 %1630 - %1631 = OpLoad %v2float %uv - OpStore %uv %876 - OpStore %uv %1631 + OpStore %1624 %950 + %1625 = OpAccessChain %_ptr_Function_float %color %uint_1 + OpStore %1625 %1623 + %1626 = OpAccessChain %_ptr_Function_float %color %uint_2 + %1627 = OpConvertSToF %float %1574 + %1628 = OpFAdd %float %1603 %1627 + OpStore %1626 %1628 + %1629 = OpLoad %v2float %uv + OpStore %uv %167 + OpStore %uv %1629 + %1630 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1631 = OpLoad %float %1630 %1632 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1633 = OpLoad %float %1632 - %1634 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1634 %float_0 - %1635 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1635 %1633 - %1636 = OpCompositeExtract %float %1058 1 - %1637 = OpCompositeExtract %float %1058 0 - %1638 = OpCompositeExtract %float %1612 1 - %1639 = OpCompositeConstruct %v3float %1636 %1637 %1638 + OpStore %1632 %950 + %1633 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1633 %1631 + %1634 = OpCompositeExtract %float %1056 1 + %1635 = OpCompositeExtract %float %1056 0 + %1636 = OpCompositeExtract %float %1610 1 + %1637 = OpCompositeConstruct %v3float %1634 %1635 %1636 + %1638 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1639 = OpLoad %float %1638 %1640 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1641 = OpLoad %float %1640 + OpStore %1640 %950 + %1641 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1641 %1639 %1642 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1642 %float_0 - %1643 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1643 %1641 - %1644 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1643 = OpLoad %float %1642 + %1644 = OpAccessChain %_ptr_Function_float %color %uint_1 %1645 = OpLoad %float %1644 %1646 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1647 = OpLoad %float %1646 - %1648 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1648 %float_0 - %1649 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1649 %1647 - %1650 = OpCompositeExtract %float %1580 1 - %1651 = OpCompositeExtract %float %1580 0 - %1652 = OpCompositeExtract %float %912 2 - %1653 = OpCompositeConstruct %v3float %1650 %1651 %1652 + OpStore %1646 %950 + %1647 = OpAccessChain %_ptr_Function_float %color %uint_1 + OpStore %1647 %1645 + %1648 = OpCompositeExtract %float %1578 1 + %1649 = OpCompositeExtract %float %1578 0 + %1650 = OpCompositeExtract %float %909 2 + %1651 = OpCompositeConstruct %v3float %1648 %1649 %1650 + %1652 = OpAccessChain %_ptr_Function_float %uv %uint_1 + %1653 = OpLoad %float %1652 %1654 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1655 = OpLoad %float %1654 + OpStore %1654 %950 + %1655 = OpAccessChain %_ptr_Function_float %uv %uint_1 + OpStore %1655 %1653 %1656 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1656 %float_0 - %1657 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1657 %1655 + %1657 = OpLoad %float %1656 %1658 = OpAccessChain %_ptr_Function_float %uv %uint_1 %1659 = OpLoad %float %1658 %1660 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1661 = OpLoad %float %1660 - %1662 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1662 %float_0 - %1663 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1663 %1661 + OpStore %1660 %950 + %1661 = OpAccessChain %_ptr_Function_float %uv %uint_1 + OpStore %1661 %1659 + %1662 = OpAccessChain %_ptr_Function_float %color %uint_2 + %1663 = OpLoad %float %1662 %1664 = OpAccessChain %_ptr_Function_float %color %uint_2 - %1665 = OpLoad %float %1664 - %1666 = OpAccessChain %_ptr_Function_float %color %uint_2 - OpStore %1666 %float_0 - %1667 = OpAccessChain %_ptr_Function_float %color %uint_2 - OpStore %1667 %1665 - %1668 = OpCompositeExtract %float %38 1 - %1669 = OpCompositeExtract %float %1363 1 - %1670 = OpCompositeExtract %float %1363 2 - %1671 = OpCompositeConstruct %v3float %1668 %1669 %1670 + OpStore %1664 %950 + %1665 = OpAccessChain %_ptr_Function_float %color %uint_2 + OpStore %1665 %1663 + %1666 = OpCompositeExtract %float %37 1 + %1667 = OpCompositeExtract %float %1361 1 + %1668 = OpCompositeExtract %float %1361 2 + %1669 = OpCompositeConstruct %v3float %1666 %1667 %1668 + %1670 = OpAccessChain %_ptr_Function_float %color %uint_2 + %1671 = OpLoad %float %1670 %1672 = OpAccessChain %_ptr_Function_float %color %uint_2 - %1673 = OpLoad %float %1672 - %1674 = OpAccessChain %_ptr_Function_float %color %uint_2 - OpStore %1674 %float_0 - %1675 = OpAccessChain %_ptr_Function_float %color %uint_2 - OpStore %1675 %1673 - %1676 = OpLoad %int %i_2 - OpStore %i_2 %int_0 - OpStore %i_2 %1676 - %1677 = OpCompositeExtract %float %1363 2 - %1678 = OpCompositeExtract %float %1363 1 - %1679 = OpCompositeConstruct %v2float %1677 %1678 - %1680 = OpLoad %v3float %color - OpStore %color %888 - OpStore %color %1680 + OpStore %1672 %950 + %1673 = OpAccessChain %_ptr_Function_float %color %uint_2 + OpStore %1673 %1671 + %1674 = OpLoad %int %i_2 + OpStore %i_2 %31 + OpStore %i_2 %1674 + %1675 = OpCompositeExtract %float %1361 2 + %1676 = OpCompositeExtract %float %1361 1 + %1677 = OpCompositeConstruct %v2float %1675 %1676 + %1678 = OpLoad %v3float %color + OpStore %color %170 + OpStore %color %1678 + %1679 = OpAccessChain %_ptr_Function_float %uv %uint_1 + %1680 = OpLoad %float %1679 %1681 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1682 = OpLoad %float %1681 - %1683 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1683 %float_0 - %1684 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1684 %1682 - %1685 = OpCompositeExtract %float %975 1 - %1686 = OpCompositeExtract %float %975 1 - %1687 = OpCompositeExtract %float %975 1 - %1688 = OpCompositeConstruct %v3float %1685 %1686 %1687 + OpStore %1681 %950 + %1682 = OpAccessChain %_ptr_Function_float %uv %uint_1 + OpStore %1682 %1680 + %1683 = OpCompositeExtract %float %973 1 + %1684 = OpCompositeExtract %float %973 1 + %1685 = OpCompositeExtract %float %973 1 + %1686 = OpCompositeConstruct %v3float %1683 %1684 %1685 + %1687 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 + %1688 = OpLoad %int %1687 %1689 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - %1690 = OpLoad %int %1689 - %1691 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - OpStore %1691 %int_0 - %1692 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 - OpStore %1692 %1690 - %1695 = OpFSub %float %1645 %1659 - %1693 = OpExtInst %float %1694 FAbs %1695 - %1696 = OpFOrdLessThan %bool %1693 %float_0_25 - OpSelectionMerge %1697 None - OpBranchConditional %1696 %1698 %1697 - %1698 = OpLabel + OpStore %1689 %31 + %1690 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_4 + OpStore %1690 %1688 + %1693 = OpFSub %float %1643 %1657 + %1691 = OpExtInst %float %1692 FAbs %1693 + %1694 = OpFOrdLessThan %bool %1691 %float_0_25 + OpSelectionMerge %1695 None + OpBranchConditional %1694 %1696 %1695 + %1696 = OpLabel + %1697 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1698 = OpLoad %float %1697 %1699 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1700 = OpLoad %float %1699 - %1701 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1701 %float_0 - %1702 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1702 %1700 - %1703 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %1703 - %1704 = OpCompositeExtract %float %1599 2 - %1705 = OpCompositeExtract %float %1599 0 - %1706 = OpCompositeExtract %float %912 0 - %1707 = OpCompositeConstruct %v3float %1704 %1705 %1706 + OpStore %1699 %950 + %1700 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1700 %1698 + %1701 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %1701 + %1702 = OpCompositeExtract %float %1597 2 + %1703 = OpCompositeExtract %float %1597 0 + %1704 = OpCompositeExtract %float %909 0 + %1705 = OpCompositeConstruct %v3float %1702 %1703 %1704 + %1706 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_8 + %1707 = OpLoad %int %1706 %1708 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_8 - %1709 = OpLoad %int %1708 - %1710 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_8 - OpStore %1710 %int_0 - %1711 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_8 - OpStore %1711 %1709 - %1713 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_9 - %1714 = OpLoad %int %1713 - %1715 = OpCompositeExtract %float %1235 1 - %1716 = OpCompositeExtract %float %1235 1 - %1717 = OpCompositeExtract %float %1235 1 - %1718 = OpCompositeConstruct %v3float %1715 %1716 %1717 + OpStore %1708 %31 + %1709 = OpAccessChain %_ptr_Private_int %obj %uint_0 %int_8 + OpStore %1709 %1707 + %1711 = OpAccessChain %_ptr_Private_int %obj %uint_0 %uint_9 + %1712 = OpLoad %int %1711 + %1713 = OpCompositeExtract %float %1233 1 + %1714 = OpCompositeExtract %float %1233 1 + %1715 = OpCompositeExtract %float %1233 1 + %1716 = OpCompositeConstruct %v3float %1713 %1714 %1715 + %1717 = OpAccessChain %_ptr_Function_float %uv %uint_1 + %1718 = OpLoad %float %1717 %1719 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1720 = OpLoad %float %1719 - %1721 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1721 %float_0 - %1722 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1722 %1720 - %1723 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1719 %950 + %1720 = OpAccessChain %_ptr_Function_float %uv %uint_1 + OpStore %1720 %1718 + %1721 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1722 = OpLoad %float %1721 + %1723 = OpAccessChain %_ptr_Function_float %uv %uint_1 %1724 = OpLoad %float %1723 %1725 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1726 = OpLoad %float %1725 - %1727 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1727 %float_0 - %1728 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1728 %1726 - %1729 = OpCompositeExtract %float %1572 0 - %1730 = OpCompositeExtract %float %1572 1 - %1731 = OpCompositeConstruct %v2float %1729 %1730 + OpStore %1725 %950 + %1726 = OpAccessChain %_ptr_Function_float %uv %uint_1 + OpStore %1726 %1724 + %1727 = OpCompositeExtract %float %1570 0 + %1728 = OpCompositeExtract %float %1570 1 + %1729 = OpCompositeConstruct %v2float %1727 %1728 + %1730 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1731 = OpLoad %float %1730 %1732 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1733 = OpLoad %float %1732 - %1734 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1734 %float_0 - %1735 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1735 %1733 - %1736 = OpLoad %v3float %color - OpStore %color %888 - OpStore %color %1736 - %1737 = OpCompositeExtract %float %956 0 - %1738 = OpCompositeExtract %float %956 0 - %1739 = OpCompositeConstruct %v2float %1737 %1738 - %1740 = OpLoad %v2float %uv - OpStore %uv %876 - OpStore %uv %1740 + OpStore %1732 %950 + %1733 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1733 %1731 + %1734 = OpLoad %v3float %color + OpStore %color %170 + OpStore %color %1734 + %1735 = OpCompositeExtract %float %954 0 + %1736 = OpCompositeExtract %float %954 0 + %1737 = OpCompositeConstruct %v2float %1735 %1736 + %1738 = OpLoad %v2float %uv + OpStore %uv %167 + OpStore %uv %1738 + %1739 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1740 = OpLoad %float %1739 %1741 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1742 = OpLoad %float %1741 - %1743 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1743 %float_0 - %1744 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1744 %1742 - %1745 = OpCompositeExtract %float %168 0 - %1746 = OpCompositeExtract %float %168 0 - %1747 = OpCompositeExtract %float %168 1 - %1748 = OpCompositeConstruct %v3float %1745 %1746 %1747 - %1749 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1750 = OpConvertSToF %float %1714 - %1751 = OpFAdd %float %1750 %1724 - OpStore %1749 %1751 + OpStore %1741 %950 + %1742 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1742 %1740 + %1743 = OpCompositeExtract %float %167 0 + %1744 = OpCompositeExtract %float %167 0 + %1745 = OpCompositeExtract %float %167 1 + %1746 = OpCompositeConstruct %v3float %1743 %1744 %1745 + %1747 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1748 = OpConvertSToF %float %1712 + %1749 = OpFAdd %float %1748 %1722 + OpStore %1747 %1749 + %1750 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1751 = OpLoad %float %1750 %1752 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1753 = OpLoad %float %1752 - %1754 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1754 %float_0 - %1755 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1755 %1753 - %1756 = OpCompositeExtract %float %1300 1 - %1757 = OpCompositeExtract %float %1639 0 - %1758 = OpCompositeExtract %float %1300 0 - %1759 = OpCompositeConstruct %v3float %1756 %1757 %1758 + OpStore %1752 %950 + %1753 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1753 %1751 + %1754 = OpCompositeExtract %float %1298 1 + %1755 = OpCompositeExtract %float %1637 0 + %1756 = OpCompositeExtract %float %1298 0 + %1757 = OpCompositeConstruct %v3float %1754 %1755 %1756 + %1758 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1759 = OpLoad %float %1758 %1760 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1761 = OpLoad %float %1760 - %1762 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1762 %float_0 - %1763 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1763 %1761 - OpBranch %1697 - %1697 = OpLabel + OpStore %1760 %950 + %1761 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1761 %1759 + OpBranch %1695 + %1695 = OpLabel + %1762 = OpAccessChain %_ptr_Function_float %uv %uint_1 + %1763 = OpLoad %float %1762 %1764 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1765 = OpLoad %float %1764 - %1766 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1766 %float_0 - %1767 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1767 %1765 - %1768 = OpLoad %v3float %color - %1769 = OpAccessChain %_ptr_Function_float %uv %int_0 - %1770 = OpLoad %float %1769 - %1771 = OpAccessChain %_ptr_Function_float %uv %int_0 - OpStore %1771 %float_0 - %1772 = OpAccessChain %_ptr_Function_float %uv %int_0 - OpStore %1772 %1770 - %1773 = OpCompositeExtract %float %904 0 - %1774 = OpCompositeExtract %float %896 0 - %1775 = OpCompositeExtract %float %896 1 - %1776 = OpCompositeConstruct %v3float %1773 %1774 %1775 - %1777 = OpExtInst %v3float %1694 Normalize %1768 + OpStore %1764 %950 + %1765 = OpAccessChain %_ptr_Function_float %uv %uint_1 + OpStore %1765 %1763 + %1766 = OpLoad %v3float %color + %1767 = OpAccessChain %_ptr_Function_float %uv %31 + %1768 = OpLoad %float %1767 + %1769 = OpAccessChain %_ptr_Function_float %uv %31 + OpStore %1769 %950 + %1770 = OpAccessChain %_ptr_Function_float %uv %31 + OpStore %1770 %1768 + %1771 = OpCompositeExtract %float %901 0 + %1772 = OpCompositeExtract %float %893 0 + %1773 = OpCompositeExtract %float %893 1 + %1774 = OpCompositeConstruct %v3float %1771 %1772 %1773 + %1775 = OpExtInst %v3float %1692 Normalize %1766 + %1776 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1777 = OpLoad %float %1776 %1778 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1779 = OpLoad %float %1778 - %1780 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1780 %float_0 - %1781 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1781 %1779 - %1782 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %1782 - %1783 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %1783 + OpStore %1778 %950 + %1779 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1779 %1777 + %1780 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %1780 + %1781 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %1781 + %1782 = OpAccessChain %_ptr_Function_float %color %uint_1 + %1783 = OpLoad %float %1782 %1784 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1785 = OpLoad %float %1784 - %1786 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1786 %float_0 - %1787 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1787 %1785 - %1788 = OpCompositeExtract %float %1612 1 - %1789 = OpCompositeExtract %float %1776 1 - %1790 = OpCompositeConstruct %v2float %1788 %1789 + OpStore %1784 %950 + %1785 = OpAccessChain %_ptr_Function_float %color %uint_1 + OpStore %1785 %1783 + %1786 = OpCompositeExtract %float %1610 1 + %1787 = OpCompositeExtract %float %1774 1 + %1788 = OpCompositeConstruct %v2float %1786 %1787 + %1789 = OpAccessChain %_ptr_Function_float %color %uint_1 + %1790 = OpLoad %float %1789 %1791 = OpAccessChain %_ptr_Function_float %color %uint_1 - %1792 = OpLoad %float %1791 - %1793 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1793 %float_0 - %1794 = OpAccessChain %_ptr_Function_float %color %uint_1 - OpStore %1794 %1792 - %1795 = OpCompositeExtract %float %1777 0 - %1796 = OpCompositeExtract %float %1777 1 - %1797 = OpCompositeExtract %float %1777 2 - %1798 = OpCompositeConstruct %v4float %1795 %1796 %1797 %float_1 + OpStore %1791 %950 + %1792 = OpAccessChain %_ptr_Function_float %color %uint_1 + OpStore %1792 %1790 + %1793 = OpCompositeExtract %float %1775 0 + %1794 = OpCompositeExtract %float %1775 1 + %1795 = OpCompositeExtract %float %1775 2 + %1796 = OpCompositeConstruct %v4float %1793 %1794 %1795 %float_1 + %1797 = OpAccessChain %_ptr_Function_float %uv %uint_1 + %1798 = OpLoad %float %1797 %1799 = OpAccessChain %_ptr_Function_float %uv %uint_1 - %1800 = OpLoad %float %1799 - %1801 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1801 %float_0 - %1802 = OpAccessChain %_ptr_Function_float %uv %uint_1 - OpStore %1802 %1800 - %1803 = OpCompositeExtract %float %38 1 - %1804 = OpCompositeExtract %float %38 1 - %1805 = OpCompositeExtract %float %1790 1 - %1806 = OpCompositeConstruct %v3float %1803 %1804 %1805 + OpStore %1799 %950 + %1800 = OpAccessChain %_ptr_Function_float %uv %uint_1 + OpStore %1800 %1798 + %1801 = OpCompositeExtract %float %37 1 + %1802 = OpCompositeExtract %float %37 1 + %1803 = OpCompositeExtract %float %1788 1 + %1804 = OpCompositeConstruct %v3float %1801 %1802 %1803 + %1805 = OpAccessChain %_ptr_Function_float %uv %uint_0 + %1806 = OpLoad %float %1805 %1807 = OpAccessChain %_ptr_Function_float %uv %uint_0 - %1808 = OpLoad %float %1807 - %1809 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1809 %float_0 - %1810 = OpAccessChain %_ptr_Function_float %uv %uint_0 - OpStore %1810 %1808 - OpStore %x_GLF_color %1798 - %1811 = OpLoad %QuicksortObject %obj - OpStore %obj %103 - OpStore %obj %1811 - %1812 = OpCompositeExtract %float %1798 3 - %1813 = OpCompositeExtract %float %1798 1 - %1814 = OpCompositeExtract %float %1462 0 - %1815 = OpCompositeConstruct %v3float %1812 %1813 %1814 + OpStore %1807 %950 + %1808 = OpAccessChain %_ptr_Function_float %uv %uint_0 + OpStore %1808 %1806 + OpStore %x_GLF_color %1796 + %1809 = OpLoad %QuicksortObject %obj + OpStore %obj %102 + OpStore %obj %1809 + %1810 = OpCompositeExtract %float %1796 3 + %1811 = OpCompositeExtract %float %1796 1 + %1812 = OpCompositeExtract %float %1460 0 + %1813 = OpCompositeConstruct %v3float %1810 %1811 %1812 + %1814 = OpAccessChain %_ptr_Function_float %color %uint_0 + %1815 = OpLoad %float %1814 %1816 = OpAccessChain %_ptr_Function_float %color %uint_0 - %1817 = OpLoad %float %1816 - %1818 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1818 %float_0 - %1819 = OpAccessChain %_ptr_Function_float %color %uint_0 - OpStore %1819 %1817 + OpStore %1816 %950 + %1817 = OpAccessChain %_ptr_Function_float %color %uint_0 + OpStore %1817 %1815 OpReturn OpFunctionEnd - %main_inner = OpFunction %main_out None %1820 + %main_inner = OpFunction %main_out None %1818 %gl_FragCoord_param = OpFunctionParameter %v4float - %1824 = OpLabel + %1822 = OpLabel OpStore %gl_FragCoord %gl_FragCoord_param - %1825 = OpFunctionCall %void %main_1 - %1826 = OpLoad %v4float %x_GLF_color - %1827 = OpCompositeConstruct %main_out %1826 - OpReturnValue %1827 + %1823 = OpFunctionCall %void %main_1 + %1824 = OpLoad %v4float %x_GLF_color + %1825 = OpCompositeConstruct %main_out %1824 + OpReturnValue %1825 OpFunctionEnd - %main = OpFunction %void None %419 - %1829 = OpLabel - %1831 = OpLoad %v4float %gl_FragCoord_param_1 - %1830 = OpFunctionCall %main_out %main_inner %1831 - %1832 = OpCompositeExtract %v4float %1830 0 - OpStore %x_GLF_color_1_1 %1832 + %main = OpFunction %void None %418 + %1827 = OpLabel + %1829 = OpLoad %v4float %gl_FragCoord_param_1 + %1828 = OpFunctionCall %main_out %main_inner %1829 + %1830 = OpCompositeExtract %v4float %1828 0 + OpStore %x_GLF_color_1_1 %1830 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/757.wgsl.expected.spvasm b/test/tint/bug/tint/757.wgsl.expected.spvasm index d19f6438a1..4ad4cef2b4 100644 --- a/test/tint/bug/tint/757.wgsl.expected.spvasm +++ b/test/tint/bug/tint/757.wgsl.expected.spvasm @@ -60,11 +60,11 @@ %v3int = OpTypeVector %int 3 %v2int = OpTypeVector %int 2 %v2uint = OpTypeVector %uint 2 - %int_0 = OpConstant %int 0 + %47 = OpConstantNull %int %_ptr_Function_v4float = OpTypePointer Function %v4float %51 = OpConstantNull %v4float - %uint_0 = OpConstant %uint 0 %bool = OpTypeBool + %uint_0 = OpConstant %uint 0 %_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float %_ptr_Function_float = OpTypePointer Function %float %74 = OpTypeFunction %void @@ -91,23 +91,23 @@ %41 = OpBitcast %v2int %44 %45 = OpCompositeExtract %int %41 0 %46 = OpCompositeExtract %int %41 1 - %48 = OpCompositeConstruct %v3int %45 %46 %int_0 - %37 = OpImageFetch %v4float %39 %48 Lod %int_0 + %48 = OpCompositeConstruct %v3int %45 %46 %47 + %37 = OpImageFetch %v4float %39 %48 Lod %47 OpStore %texel %37 - OpStore %i %uint_0 - OpBranch %54 - %54 = OpLabel - OpLoopMerge %55 %56 None - OpBranch %57 - %57 = OpLabel - %59 = OpLoad %uint %i - %60 = OpULessThan %bool %59 %uint_1 - %58 = OpLogicalNot %bool %60 - OpSelectionMerge %62 None - OpBranchConditional %58 %63 %62 - %63 = OpLabel - OpBranch %55 + OpStore %i %33 + OpBranch %53 + %53 = OpLabel + OpLoopMerge %54 %55 None + OpBranch %56 + %56 = OpLabel + %58 = OpLoad %uint %i + %59 = OpULessThan %bool %58 %uint_1 + %57 = OpLogicalNot %bool %59 + OpSelectionMerge %61 None + OpBranchConditional %57 %62 %61 %62 = OpLabel + OpBranch %54 + %61 = OpLabel %64 = OpLoad %uint %flatIndex %65 = OpLoad %uint %i %66 = OpIAdd %uint %64 %65 @@ -115,13 +115,13 @@ %70 = OpAccessChain %_ptr_Function_float %texel %uint_0 %71 = OpLoad %float %70 OpStore %68 %71 - OpBranch %56 - %56 = OpLabel + OpBranch %55 + %55 = OpLabel %72 = OpLoad %uint %i %73 = OpIAdd %uint %72 %uint_1 OpStore %i %73 - OpBranch %54 - %55 = OpLabel + OpBranch %53 + %54 = OpLabel OpReturn OpFunctionEnd %main = OpFunction %void None %74 diff --git a/test/tint/bug/tint/764.wgsl.expected.spvasm b/test/tint/bug/tint/764.wgsl.expected.spvasm index 5261691a73..329c64e7df 100644 --- a/test/tint/bug/tint/764.wgsl.expected.spvasm +++ b/test/tint/bug/tint/764.wgsl.expected.spvasm @@ -18,7 +18,7 @@ %11 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 %12 = OpConstantComposite %mat4v4float %11 %11 %11 %11 %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %14 = OpConstantNull %int %unused_entry_point = OpFunction %void None %1 %4 = OpLabel OpReturn diff --git a/test/tint/bug/tint/827.wgsl.expected.spvasm b/test/tint/bug/tint/827.wgsl.expected.spvasm index b1fda45601..29e60f637f 100644 --- a/test/tint/bug/tint/827.wgsl.expected.spvasm +++ b/test/tint/bug/tint/827.wgsl.expected.spvasm @@ -44,7 +44,7 @@ %v4float = OpTypeVector %float 4 %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 - %int_0 = OpConstant %int 0 + %37 = OpConstantNull %int %38 = OpTypeFunction %void %main_inner = OpFunction %void None %14 %GlobalInvocationId = OpFunctionParameter %v3uint @@ -60,7 +60,7 @@ %35 = OpCompositeExtract %uint %GlobalInvocationId 1 %34 = OpBitcast %int %35 %36 = OpCompositeConstruct %v2int %32 %34 - %27 = OpImageFetch %v4float %29 %36 Lod %int_0 + %27 = OpImageFetch %v4float %29 %36 Lod %37 %26 = OpCompositeExtract %float %27 0 OpStore %25 %26 OpReturn diff --git a/test/tint/bug/tint/870.spvasm.expected.spvasm b/test/tint/bug/tint/870.spvasm.expected.spvasm index d502ddabf4..9b6a8004f2 100644 --- a/test/tint/bug/tint/870.spvasm.expected.spvasm +++ b/test/tint/bug/tint/870.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 49 +; Bound: 50 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -45,8 +45,9 @@ %uint_0 = OpConstant %uint 0 %uint_3 = OpConstant %uint 3 %_ptr_StorageBuffer__arr_int_uint_6 = OpTypePointer StorageBuffer %_arr_int_uint_6 - %int_0 = OpConstant %int 0 + %23 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int + %26 = OpConstantNull %uint %int_1 = OpConstant %int 1 %uint_1 = OpConstant %uint 1 %int_2 = OpConstant %int 2 @@ -61,28 +62,28 @@ %orientation = OpVariable %_ptr_Function__arr_int_uint_6 Function %17 %21 = OpAccessChain %_ptr_StorageBuffer__arr_int_uint_6 %sspp962805860buildInformation %uint_0 %uint_3 %22 = OpLoad %_arr_int_uint_6 %21 - %25 = OpAccessChain %_ptr_Function_int %orientation %int_0 - %26 = OpCompositeExtract %int %22 0 - OpStore %25 %26 - %28 = OpAccessChain %_ptr_Function_int %orientation %int_1 - %30 = OpCompositeExtract %int %22 1 - OpStore %28 %30 - %32 = OpAccessChain %_ptr_Function_int %orientation %int_2 - %34 = OpCompositeExtract %int %22 2 - OpStore %32 %34 - %36 = OpAccessChain %_ptr_Function_int %orientation %int_3 - %37 = OpCompositeExtract %int %22 3 - OpStore %36 %37 - %39 = OpAccessChain %_ptr_Function_int %orientation %int_4 - %41 = OpCompositeExtract %int %22 4 - OpStore %39 %41 - %43 = OpAccessChain %_ptr_Function_int %orientation %int_5 - %45 = OpCompositeExtract %int %22 5 - OpStore %43 %45 + %25 = OpAccessChain %_ptr_Function_int %orientation %23 + %27 = OpCompositeExtract %int %22 0 + OpStore %25 %27 + %29 = OpAccessChain %_ptr_Function_int %orientation %int_1 + %31 = OpCompositeExtract %int %22 1 + OpStore %29 %31 + %33 = OpAccessChain %_ptr_Function_int %orientation %int_2 + %35 = OpCompositeExtract %int %22 2 + OpStore %33 %35 + %37 = OpAccessChain %_ptr_Function_int %orientation %int_3 + %38 = OpCompositeExtract %int %22 3 + OpStore %37 %38 + %40 = OpAccessChain %_ptr_Function_int %orientation %int_4 + %42 = OpCompositeExtract %int %22 4 + OpStore %40 %42 + %44 = OpAccessChain %_ptr_Function_int %orientation %int_5 + %46 = OpCompositeExtract %int %22 5 + OpStore %44 %46 OpReturn OpFunctionEnd %main = OpFunction %void None %11 - %47 = OpLabel - %48 = OpFunctionCall %void %main_1 + %48 = OpLabel + %49 = OpFunctionCall %void %main_1 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/913.wgsl.expected.spvasm b/test/tint/bug/tint/913.wgsl.expected.spvasm index 73b58b380b..29d8c168b7 100644 --- a/test/tint/bug/tint/913.wgsl.expected.spvasm +++ b/test/tint/bug/tint/913.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 205 +; Bound: 207 ; Schema: 0 OpCapability Shader OpCapability ImageQuery @@ -92,14 +92,16 @@ %_ptr_Uniform_uint = OpTypePointer Uniform %uint %uint_1 = OpConstant %uint 1 %uint_4 = OpConstant %uint 4 + %97 = OpConstantNull %int %v4bool = OpTypeVector %bool 4 %_ptr_Uniform_v2uint = OpTypePointer Uniform %v2uint %uint_2 = OpConstant %uint 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint - %110 = OpConstantNull %v2uint + %111 = OpConstantNull %v2uint %_ptr_Function_uint = OpTypePointer Function %uint %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint - %200 = OpTypeFunction %void + %201 = OpConstantNull %uint + %202 = OpTypeFunction %void %aboutEqual = OpFunction %bool None %18 %value = OpFunctionParameter %float %expect = OpFunctionParameter %float @@ -113,7 +115,7 @@ %GlobalInvocationID = OpFunctionParameter %v3uint %33 = OpLabel %success = OpVariable %_ptr_Function_bool Function %50 -%srcTexCoord = OpVariable %_ptr_Function_v2uint Function %110 +%srcTexCoord = OpVariable %_ptr_Function_v2uint Function %111 %tint_symbol_1 = OpVariable %_ptr_Function_bool Function %50 %tint_symbol = OpVariable %_ptr_Function_bool Function %50 %tint_symbol_5 = OpVariable %_ptr_Function_bool Function %50 @@ -175,156 +177,156 @@ %92 = OpLabel %95 = OpLoad %7 %dst %96 = OpBitcast %v2int %42 - %94 = OpImageFetch %v4float %95 %96 Lod %int_0 - %97 = OpFOrdEqual %v4bool %94 %46 - %93 = OpAll %bool %97 + %94 = OpImageFetch %v4float %95 %96 Lod %97 + %98 = OpFOrdEqual %v4bool %94 %46 + %93 = OpAll %bool %98 OpBranch %91 %91 = OpLabel - %99 = OpPhi %bool %90 %88 %93 %92 - OpStore %success %99 + %100 = OpPhi %bool %90 %88 %93 %92 + OpStore %success %100 OpBranch %87 %89 = OpLabel - %101 = OpAccessChain %_ptr_Uniform_v2uint %uniforms %uint_3 - %102 = OpLoad %v2uint %101 - %103 = OpISub %v2uint %42 %102 - %105 = OpAccessChain %_ptr_Uniform_v2uint %uniforms %uint_2 - %106 = OpLoad %v2uint %105 - %107 = OpIAdd %v2uint %103 %106 - OpStore %srcTexCoord %107 - %111 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 - %112 = OpLoad %uint %111 - %113 = OpIEqual %bool %112 %uint_1 - OpSelectionMerge %114 None - OpBranchConditional %113 %115 %114 + %102 = OpAccessChain %_ptr_Uniform_v2uint %uniforms %uint_3 + %103 = OpLoad %v2uint %102 + %104 = OpISub %v2uint %42 %103 + %106 = OpAccessChain %_ptr_Uniform_v2uint %uniforms %uint_2 + %107 = OpLoad %v2uint %106 + %108 = OpIAdd %v2uint %104 %107 + OpStore %srcTexCoord %108 + %112 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 + %113 = OpLoad %uint %112 + %114 = OpIEqual %bool %113 %uint_1 + OpSelectionMerge %115 None + OpBranchConditional %114 %116 %115 + %116 = OpLabel + %118 = OpAccessChain %_ptr_Function_uint %srcTexCoord %uint_1 + %120 = OpCompositeExtract %int %34 1 + %119 = OpBitcast %uint %120 + %121 = OpAccessChain %_ptr_Function_uint %srcTexCoord %uint_1 + %122 = OpLoad %uint %121 + %123 = OpISub %uint %119 %122 + %124 = OpISub %uint %123 %uint_1 + OpStore %118 %124 + OpBranch %115 %115 = OpLabel - %117 = OpAccessChain %_ptr_Function_uint %srcTexCoord %uint_1 - %119 = OpCompositeExtract %int %34 1 - %118 = OpBitcast %uint %119 - %120 = OpAccessChain %_ptr_Function_uint %srcTexCoord %uint_1 - %121 = OpLoad %uint %120 - %122 = OpISub %uint %118 %121 - %123 = OpISub %uint %122 %uint_1 - OpStore %117 %123 - OpBranch %114 - %114 = OpLabel - %125 = OpLoad %7 %src - %127 = OpLoad %v2uint %srcTexCoord - %126 = OpBitcast %v2int %127 - %124 = OpImageFetch %v4float %125 %126 Lod %int_0 - %129 = OpLoad %7 %dst - %130 = OpBitcast %v2int %42 - %128 = OpImageFetch %v4float %129 %130 Lod %int_0 - %131 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 - %132 = OpLoad %uint %131 - %133 = OpIEqual %bool %132 %uint_2 - OpSelectionMerge %134 None - OpBranchConditional %133 %135 %136 - %135 = OpLabel - %137 = OpLoad %bool %success - OpStore %tint_symbol_1 %137 - %139 = OpLoad %bool %tint_symbol_1 - OpSelectionMerge %140 None - OpBranchConditional %139 %141 %140 - %141 = OpLabel - %143 = OpCompositeExtract %float %128 0 - %144 = OpCompositeExtract %float %124 0 - %142 = OpFunctionCall %bool %aboutEqual %143 %144 - OpStore %tint_symbol_1 %142 - OpBranch %140 - %140 = OpLabel - %145 = OpLoad %bool %tint_symbol_1 - OpStore %tint_symbol %145 - %147 = OpLoad %bool %tint_symbol - OpSelectionMerge %148 None - OpBranchConditional %147 %149 %148 - %149 = OpLabel - %151 = OpCompositeExtract %float %128 1 - %152 = OpCompositeExtract %float %124 1 - %150 = OpFunctionCall %bool %aboutEqual %151 %152 - OpStore %tint_symbol %150 - OpBranch %148 - %148 = OpLabel - %153 = OpLoad %bool %tint_symbol - OpStore %success %153 - OpBranch %134 + %126 = OpLoad %7 %src + %128 = OpLoad %v2uint %srcTexCoord + %127 = OpBitcast %v2int %128 + %125 = OpImageFetch %v4float %126 %127 Lod %97 + %130 = OpLoad %7 %dst + %131 = OpBitcast %v2int %42 + %129 = OpImageFetch %v4float %130 %131 Lod %97 + %132 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 + %133 = OpLoad %uint %132 + %134 = OpIEqual %bool %133 %uint_2 + OpSelectionMerge %135 None + OpBranchConditional %134 %136 %137 %136 = OpLabel - %154 = OpLoad %bool %success - OpStore %tint_symbol_5 %154 - %156 = OpLoad %bool %tint_symbol_5 - OpSelectionMerge %157 None - OpBranchConditional %156 %158 %157 + %138 = OpLoad %bool %success + OpStore %tint_symbol_1 %138 + %140 = OpLoad %bool %tint_symbol_1 + OpSelectionMerge %141 None + OpBranchConditional %140 %142 %141 + %142 = OpLabel + %144 = OpCompositeExtract %float %129 0 + %145 = OpCompositeExtract %float %125 0 + %143 = OpFunctionCall %bool %aboutEqual %144 %145 + OpStore %tint_symbol_1 %143 + OpBranch %141 + %141 = OpLabel + %146 = OpLoad %bool %tint_symbol_1 + OpStore %tint_symbol %146 + %148 = OpLoad %bool %tint_symbol + OpSelectionMerge %149 None + OpBranchConditional %148 %150 %149 + %150 = OpLabel + %152 = OpCompositeExtract %float %129 1 + %153 = OpCompositeExtract %float %125 1 + %151 = OpFunctionCall %bool %aboutEqual %152 %153 + OpStore %tint_symbol %151 + OpBranch %149 + %149 = OpLabel + %154 = OpLoad %bool %tint_symbol + OpStore %success %154 + OpBranch %135 + %137 = OpLabel + %155 = OpLoad %bool %success + OpStore %tint_symbol_5 %155 + %157 = OpLoad %bool %tint_symbol_5 + OpSelectionMerge %158 None + OpBranchConditional %157 %159 %158 + %159 = OpLabel + %161 = OpCompositeExtract %float %129 0 + %162 = OpCompositeExtract %float %125 0 + %160 = OpFunctionCall %bool %aboutEqual %161 %162 + OpStore %tint_symbol_5 %160 + OpBranch %158 %158 = OpLabel - %160 = OpCompositeExtract %float %128 0 - %161 = OpCompositeExtract %float %124 0 - %159 = OpFunctionCall %bool %aboutEqual %160 %161 - OpStore %tint_symbol_5 %159 - OpBranch %157 - %157 = OpLabel - %162 = OpLoad %bool %tint_symbol_5 - OpStore %tint_symbol_4 %162 - %164 = OpLoad %bool %tint_symbol_4 - OpSelectionMerge %165 None - OpBranchConditional %164 %166 %165 + %163 = OpLoad %bool %tint_symbol_5 + OpStore %tint_symbol_4 %163 + %165 = OpLoad %bool %tint_symbol_4 + OpSelectionMerge %166 None + OpBranchConditional %165 %167 %166 + %167 = OpLabel + %169 = OpCompositeExtract %float %129 1 + %170 = OpCompositeExtract %float %125 1 + %168 = OpFunctionCall %bool %aboutEqual %169 %170 + OpStore %tint_symbol_4 %168 + OpBranch %166 %166 = OpLabel - %168 = OpCompositeExtract %float %128 1 - %169 = OpCompositeExtract %float %124 1 - %167 = OpFunctionCall %bool %aboutEqual %168 %169 - OpStore %tint_symbol_4 %167 - OpBranch %165 - %165 = OpLabel - %170 = OpLoad %bool %tint_symbol_4 - OpStore %tint_symbol_3 %170 - %172 = OpLoad %bool %tint_symbol_3 - OpSelectionMerge %173 None - OpBranchConditional %172 %174 %173 + %171 = OpLoad %bool %tint_symbol_4 + OpStore %tint_symbol_3 %171 + %173 = OpLoad %bool %tint_symbol_3 + OpSelectionMerge %174 None + OpBranchConditional %173 %175 %174 + %175 = OpLabel + %177 = OpCompositeExtract %float %129 2 + %178 = OpCompositeExtract %float %125 2 + %176 = OpFunctionCall %bool %aboutEqual %177 %178 + OpStore %tint_symbol_3 %176 + OpBranch %174 %174 = OpLabel - %176 = OpCompositeExtract %float %128 2 - %177 = OpCompositeExtract %float %124 2 - %175 = OpFunctionCall %bool %aboutEqual %176 %177 - OpStore %tint_symbol_3 %175 - OpBranch %173 - %173 = OpLabel - %178 = OpLoad %bool %tint_symbol_3 - OpStore %tint_symbol_2 %178 - %180 = OpLoad %bool %tint_symbol_2 - OpSelectionMerge %181 None - OpBranchConditional %180 %182 %181 + %179 = OpLoad %bool %tint_symbol_3 + OpStore %tint_symbol_2 %179 + %181 = OpLoad %bool %tint_symbol_2 + OpSelectionMerge %182 None + OpBranchConditional %181 %183 %182 + %183 = OpLabel + %185 = OpCompositeExtract %float %129 3 + %186 = OpCompositeExtract %float %125 3 + %184 = OpFunctionCall %bool %aboutEqual %185 %186 + OpStore %tint_symbol_2 %184 + OpBranch %182 %182 = OpLabel - %184 = OpCompositeExtract %float %128 3 - %185 = OpCompositeExtract %float %124 3 - %183 = OpFunctionCall %bool %aboutEqual %184 %185 - OpStore %tint_symbol_2 %183 - OpBranch %181 - %181 = OpLabel - %186 = OpLoad %bool %tint_symbol_2 - OpStore %success %186 - OpBranch %134 - %134 = OpLabel + %187 = OpLoad %bool %tint_symbol_2 + OpStore %success %187 + OpBranch %135 + %135 = OpLabel OpBranch %87 %87 = OpLabel - %187 = OpCompositeExtract %uint %GlobalInvocationID 1 - %189 = OpCompositeExtract %int %39 0 - %188 = OpBitcast %uint %189 - %190 = OpIMul %uint %187 %188 - %191 = OpCompositeExtract %uint %GlobalInvocationID 0 - %192 = OpIAdd %uint %190 %191 - %193 = OpLoad %bool %success - OpSelectionMerge %194 None - OpBranchConditional %193 %195 %196 - %195 = OpLabel - %198 = OpAccessChain %_ptr_StorageBuffer_uint %output %uint_0 %192 - OpStore %198 %uint_1 - OpBranch %194 + %188 = OpCompositeExtract %uint %GlobalInvocationID 1 + %190 = OpCompositeExtract %int %39 0 + %189 = OpBitcast %uint %190 + %191 = OpIMul %uint %188 %189 + %192 = OpCompositeExtract %uint %GlobalInvocationID 0 + %193 = OpIAdd %uint %191 %192 + %194 = OpLoad %bool %success + OpSelectionMerge %195 None + OpBranchConditional %194 %196 %197 %196 = OpLabel - %199 = OpAccessChain %_ptr_StorageBuffer_uint %output %uint_0 %192 - OpStore %199 %uint_0 - OpBranch %194 - %194 = OpLabel + %199 = OpAccessChain %_ptr_StorageBuffer_uint %output %uint_0 %193 + OpStore %199 %uint_1 + OpBranch %195 + %197 = OpLabel + %200 = OpAccessChain %_ptr_StorageBuffer_uint %output %uint_0 %193 + OpStore %200 %201 + OpBranch %195 + %195 = OpLabel OpReturn OpFunctionEnd - %main = OpFunction %void None %200 - %202 = OpLabel - %204 = OpLoad %v3uint %GlobalInvocationID_1 - %203 = OpFunctionCall %void %main_inner %204 + %main = OpFunction %void None %202 + %204 = OpLabel + %206 = OpLoad %v3uint %GlobalInvocationID_1 + %205 = OpFunctionCall %void %main_inner %206 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/914.wgsl.expected.spvasm b/test/tint/bug/tint/914.wgsl.expected.spvasm index 48ce37eb2c..460cc217a6 100644 --- a/test/tint/bug/tint/914.wgsl.expected.spvasm +++ b/test/tint/bug/tint/914.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 375 +; Bound: 374 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -114,7 +114,7 @@ %bool = OpTypeBool %uint_1 = OpConstant %uint 1 %_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float - %float_0 = OpConstant %float 0 + %52 = OpConstantNull %float %uint_2 = OpConstant %uint 2 %void = OpTypeVoid %75 = OpTypeFunction %void %uint %uint %float @@ -123,18 +123,17 @@ %106 = OpConstantNull %uint %uint_4096 = OpConstant %uint 4096 %_ptr_Workgroup_float = OpTypePointer Workgroup %float - %123 = OpConstantNull %float %uint_256 = OpConstant %uint 256 %uint_264 = OpConstant %uint 264 %uint_16 = OpConstant %uint 16 %_arr_float_uint_16 = OpTypeArray %float %uint_16 %_ptr_Function__arr_float_uint_16 = OpTypePointer Function %_arr_float_uint_16 - %147 = OpConstantNull %_arr_float_uint_16 + %146 = OpConstantNull %_arr_float_uint_16 %_ptr_Function_float = OpTypePointer Function %float %_arr_float_RowPerThread = OpTypeArray %float %RowPerThread %_ptr_Function__arr_float_RowPerThread = OpTypePointer Function %_arr_float_RowPerThread - %153 = OpConstantNull %_arr_float_RowPerThread - %368 = OpTypeFunction %void + %152 = OpConstantNull %_arr_float_RowPerThread + %367 = OpTypeFunction %void %mm_readA = OpFunction %float None %25 %row = OpFunctionParameter %uint %col = OpFunctionParameter %uint @@ -162,7 +161,7 @@ %51 = OpLoad %float %50 OpReturnValue %51 %43 = OpLabel - OpReturnValue %float_0 + OpReturnValue %52 OpFunctionEnd %mm_readB = OpFunction %float None %25 %row_0 = OpFunctionParameter %uint @@ -191,7 +190,7 @@ %74 = OpLoad %float %73 OpReturnValue %74 %67 = OpLabel - OpReturnValue %float_0 + OpReturnValue %52 OpFunctionEnd %mm_write = OpFunction %void None %75 %row_1 = OpFunctionParameter %uint @@ -229,9 +228,9 @@ %local_invocation_index = OpFunctionParameter %uint %103 = OpLabel %idx = OpVariable %_ptr_Function_uint Function %106 - %acc = OpVariable %_ptr_Function__arr_float_uint_16 Function %147 - %ACached = OpVariable %_ptr_Function_float Function %123 - %BCached = OpVariable %_ptr_Function__arr_float_RowPerThread Function %153 + %acc = OpVariable %_ptr_Function__arr_float_uint_16 Function %146 + %ACached = OpVariable %_ptr_Function_float Function %52 + %BCached = OpVariable %_ptr_Function__arr_float_RowPerThread Function %152 %index = OpVariable %_ptr_Function_uint Function %106 %t = OpVariable %_ptr_Function_uint Function %106 %innerRow = OpVariable %_ptr_Function_uint Function %106 @@ -263,365 +262,365 @@ %119 = OpLoad %uint %idx %120 = OpUMod %uint %119 %TileAOuter %122 = OpAccessChain %_ptr_Workgroup_float %mm_Asub %118 %120 - OpStore %122 %123 - %124 = OpAccessChain %_ptr_Workgroup_float %mm_Bsub %118 %120 - OpStore %124 %123 + OpStore %122 %52 + %123 = OpAccessChain %_ptr_Workgroup_float %mm_Bsub %118 %120 + OpStore %123 %52 OpBranch %109 %109 = OpLabel - %125 = OpLoad %uint %idx - %127 = OpIAdd %uint %125 %uint_256 - OpStore %idx %127 + %124 = OpLoad %uint %idx + %126 = OpIAdd %uint %124 %uint_256 + OpStore %idx %126 OpBranch %107 %108 = OpLabel OpControlBarrier %uint_2 %uint_2 %uint_264 - %130 = OpCompositeExtract %uint %local_id 1 - %131 = OpIMul %uint %130 %RowPerThread - %132 = OpCompositeExtract %uint %local_id 0 - %133 = OpIMul %uint %132 %RowPerThread - %134 = OpCompositeExtract %uint %global_id 1 - %135 = OpIMul %uint %134 %RowPerThread - %136 = OpCompositeExtract %uint %global_id 0 - %137 = OpIMul %uint %136 %RowPerThread - %138 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 - %139 = OpLoad %uint %138 - %140 = OpISub %uint %139 %uint_1 - %141 = OpUDiv %uint %140 %TileAOuter - %142 = OpIAdd %uint %141 %uint_1 - OpStore %index %uint_0 - OpBranch %155 - %155 = OpLabel - OpLoopMerge %156 %157 None - OpBranch %158 - %158 = OpLabel - %160 = OpLoad %uint %index - %161 = OpIMul %uint %RowPerThread %RowPerThread - %162 = OpULessThan %bool %160 %161 - %159 = OpLogicalNot %bool %162 - OpSelectionMerge %163 None - OpBranchConditional %159 %164 %163 - %164 = OpLabel - OpBranch %156 - %163 = OpLabel - %165 = OpLoad %uint %index - %166 = OpAccessChain %_ptr_Function_float %acc %165 - OpStore %166 %float_0 + %129 = OpCompositeExtract %uint %local_id 1 + %130 = OpIMul %uint %129 %RowPerThread + %131 = OpCompositeExtract %uint %local_id 0 + %132 = OpIMul %uint %131 %RowPerThread + %133 = OpCompositeExtract %uint %global_id 1 + %134 = OpIMul %uint %133 %RowPerThread + %135 = OpCompositeExtract %uint %global_id 0 + %136 = OpIMul %uint %135 %RowPerThread + %137 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_1 + %138 = OpLoad %uint %137 + %139 = OpISub %uint %138 %uint_1 + %140 = OpUDiv %uint %139 %TileAOuter + %141 = OpIAdd %uint %140 %uint_1 + OpStore %index %106 + OpBranch %154 + %154 = OpLabel + OpLoopMerge %155 %156 None OpBranch %157 %157 = OpLabel - %167 = OpLoad %uint %index - %168 = OpIAdd %uint %167 %uint_1 - OpStore %index %168 + %159 = OpLoad %uint %index + %160 = OpIMul %uint %RowPerThread %RowPerThread + %161 = OpULessThan %bool %159 %160 + %158 = OpLogicalNot %bool %161 + OpSelectionMerge %162 None + OpBranchConditional %158 %163 %162 + %163 = OpLabel OpBranch %155 + %162 = OpLabel + %164 = OpLoad %uint %index + %165 = OpAccessChain %_ptr_Function_float %acc %164 + OpStore %165 %52 + OpBranch %156 %156 = OpLabel - %169 = OpUDiv %uint %TileAOuter %uint_16 - %170 = OpCompositeExtract %uint %local_id 0 - %171 = OpIMul %uint %170 %169 - %172 = OpUDiv %uint %TileAOuter %uint_16 - %173 = OpCompositeExtract %uint %local_id 1 - %174 = OpIMul %uint %173 %172 - OpStore %t %uint_0 - OpBranch %176 - %176 = OpLabel - OpLoopMerge %177 %178 None - OpBranch %179 - %179 = OpLabel - %181 = OpLoad %uint %t - %182 = OpULessThan %bool %181 %142 - %180 = OpLogicalNot %bool %182 - OpSelectionMerge %183 None - OpBranchConditional %180 %184 %183 - %184 = OpLabel - OpBranch %177 - %183 = OpLabel - OpStore %innerRow %uint_0 - OpBranch %186 - %186 = OpLabel - OpLoopMerge %187 %188 None - OpBranch %189 - %189 = OpLabel - %191 = OpLoad %uint %innerRow - %192 = OpULessThan %bool %191 %RowPerThread - %190 = OpLogicalNot %bool %192 - OpSelectionMerge %193 None - OpBranchConditional %190 %194 %193 - %194 = OpLabel - OpBranch %187 - %193 = OpLabel - OpStore %innerCol %uint_0 - OpBranch %196 - %196 = OpLabel - OpLoopMerge %197 %198 None - OpBranch %199 - %199 = OpLabel - %201 = OpLoad %uint %innerCol - %202 = OpULessThan %bool %201 %169 - %200 = OpLogicalNot %bool %202 - OpSelectionMerge %203 None - OpBranchConditional %200 %204 %203 - %204 = OpLabel - OpBranch %197 - %203 = OpLabel - %205 = OpLoad %uint %innerRow - %206 = OpIAdd %uint %131 %205 - %207 = OpLoad %uint %innerCol - %208 = OpIAdd %uint %171 %207 - %210 = OpLoad %uint %innerRow - %211 = OpIAdd %uint %135 %210 - %212 = OpLoad %uint %t - %213 = OpIMul %uint %212 %TileAOuter - %214 = OpIAdd %uint %213 %208 - %209 = OpFunctionCall %float %mm_readA %211 %214 - %215 = OpAccessChain %_ptr_Workgroup_float %mm_Asub %206 %208 - OpStore %215 %209 - OpBranch %198 - %198 = OpLabel - %216 = OpLoad %uint %innerCol - %217 = OpIAdd %uint %216 %uint_1 - OpStore %innerCol %217 - OpBranch %196 - %197 = OpLabel - OpBranch %188 - %188 = OpLabel - %218 = OpLoad %uint %innerRow - %219 = OpIAdd %uint %218 %uint_1 - OpStore %innerRow %219 - OpBranch %186 - %187 = OpLabel - OpStore %innerRow_0 %uint_0 - OpBranch %221 - %221 = OpLabel - OpLoopMerge %222 %223 None - OpBranch %224 - %224 = OpLabel - %226 = OpLoad %uint %innerRow_0 - %227 = OpULessThan %bool %226 %172 - %225 = OpLogicalNot %bool %227 - OpSelectionMerge %228 None - OpBranchConditional %225 %229 %228 - %229 = OpLabel - OpBranch %222 - %228 = OpLabel - OpStore %innerCol_0 %uint_0 - OpBranch %231 - %231 = OpLabel - OpLoopMerge %232 %233 None - OpBranch %234 - %234 = OpLabel - %236 = OpLoad %uint %innerCol_0 - %237 = OpULessThan %bool %236 %RowPerThread - %235 = OpLogicalNot %bool %237 - OpSelectionMerge %238 None - OpBranchConditional %235 %239 %238 - %239 = OpLabel - OpBranch %232 - %238 = OpLabel - %240 = OpLoad %uint %innerRow_0 - %241 = OpIAdd %uint %174 %240 - %242 = OpLoad %uint %innerCol_0 - %243 = OpIAdd %uint %133 %242 - %245 = OpLoad %uint %t - %246 = OpIMul %uint %245 %TileAOuter - %247 = OpIAdd %uint %246 %241 - %248 = OpLoad %uint %innerCol_0 - %249 = OpIAdd %uint %137 %248 - %244 = OpFunctionCall %float %mm_readB %247 %249 - %250 = OpLoad %uint %innerCol_0 - %251 = OpAccessChain %_ptr_Workgroup_float %mm_Bsub %250 %243 - OpStore %251 %244 - OpBranch %233 - %233 = OpLabel - %252 = OpLoad %uint %innerCol_0 - %253 = OpIAdd %uint %252 %uint_1 - OpStore %innerCol_0 %253 - OpBranch %231 - %232 = OpLabel - OpBranch %223 - %223 = OpLabel - %254 = OpLoad %uint %innerRow_0 - %255 = OpIAdd %uint %254 %uint_1 - OpStore %innerRow_0 %255 - OpBranch %221 - %222 = OpLabel - OpControlBarrier %uint_2 %uint_2 %uint_264 - OpStore %k %uint_0 - OpBranch %258 - %258 = OpLabel - OpLoopMerge %259 %260 None - OpBranch %261 - %261 = OpLabel - %263 = OpLoad %uint %k - %264 = OpULessThan %bool %263 %TileAOuter - %262 = OpLogicalNot %bool %264 - OpSelectionMerge %265 None - OpBranchConditional %262 %266 %265 - %266 = OpLabel - OpBranch %259 - %265 = OpLabel - OpStore %inner %uint_0 - OpBranch %268 - %268 = OpLabel - OpLoopMerge %269 %270 None - OpBranch %271 - %271 = OpLabel - %273 = OpLoad %uint %inner - %274 = OpULessThan %bool %273 %RowPerThread - %272 = OpLogicalNot %bool %274 - OpSelectionMerge %275 None - OpBranchConditional %272 %276 %275 - %276 = OpLabel - OpBranch %269 - %275 = OpLabel - %277 = OpLoad %uint %inner - %278 = OpAccessChain %_ptr_Function_float %BCached %277 - %279 = OpLoad %uint %k - %280 = OpLoad %uint %inner - %281 = OpIAdd %uint %133 %280 - %282 = OpAccessChain %_ptr_Workgroup_float %mm_Bsub %279 %281 - %283 = OpLoad %float %282 - OpStore %278 %283 - OpBranch %270 - %270 = OpLabel - %284 = OpLoad %uint %inner - %285 = OpIAdd %uint %284 %uint_1 - OpStore %inner %285 - OpBranch %268 - %269 = OpLabel - OpStore %innerRow_1 %uint_0 - OpBranch %287 - %287 = OpLabel - OpLoopMerge %288 %289 None - OpBranch %290 - %290 = OpLabel - %292 = OpLoad %uint %innerRow_1 - %293 = OpULessThan %bool %292 %RowPerThread - %291 = OpLogicalNot %bool %293 - OpSelectionMerge %294 None - OpBranchConditional %291 %295 %294 - %295 = OpLabel - OpBranch %288 - %294 = OpLabel - %296 = OpLoad %uint %innerRow_1 - %297 = OpIAdd %uint %131 %296 - %298 = OpLoad %uint %k - %299 = OpAccessChain %_ptr_Workgroup_float %mm_Asub %297 %298 - %300 = OpLoad %float %299 - OpStore %ACached %300 - OpStore %innerCol_1 %uint_0 - OpBranch %302 - %302 = OpLabel - OpLoopMerge %303 %304 None - OpBranch %305 - %305 = OpLabel - %307 = OpLoad %uint %innerCol_1 - %308 = OpULessThan %bool %307 %RowPerThread - %306 = OpLogicalNot %bool %308 - OpSelectionMerge %309 None - OpBranchConditional %306 %310 %309 - %310 = OpLabel - OpBranch %303 - %309 = OpLabel - %311 = OpLoad %uint %innerRow_1 - %312 = OpIMul %uint %311 %RowPerThread - %313 = OpLoad %uint %innerCol_1 - %314 = OpIAdd %uint %312 %313 - %315 = OpAccessChain %_ptr_Function_float %acc %314 - %316 = OpAccessChain %_ptr_Function_float %acc %314 - %317 = OpLoad %float %316 - %318 = OpLoad %float %ACached - %319 = OpLoad %uint %innerCol_1 - %320 = OpAccessChain %_ptr_Function_float %BCached %319 - %321 = OpLoad %float %320 - %322 = OpFMul %float %318 %321 - %323 = OpFAdd %float %317 %322 - OpStore %315 %323 - OpBranch %304 - %304 = OpLabel - %324 = OpLoad %uint %innerCol_1 - %325 = OpIAdd %uint %324 %uint_1 - OpStore %innerCol_1 %325 - OpBranch %302 - %303 = OpLabel - OpBranch %289 - %289 = OpLabel - %326 = OpLoad %uint %innerRow_1 - %327 = OpIAdd %uint %326 %uint_1 - OpStore %innerRow_1 %327 - OpBranch %287 - %288 = OpLabel - OpBranch %260 - %260 = OpLabel - %328 = OpLoad %uint %k - %329 = OpIAdd %uint %328 %uint_1 - OpStore %k %329 - OpBranch %258 - %259 = OpLabel - OpControlBarrier %uint_2 %uint_2 %uint_264 + %166 = OpLoad %uint %index + %167 = OpIAdd %uint %166 %uint_1 + OpStore %index %167 + OpBranch %154 + %155 = OpLabel + %168 = OpUDiv %uint %TileAOuter %uint_16 + %169 = OpCompositeExtract %uint %local_id 0 + %170 = OpIMul %uint %169 %168 + %171 = OpUDiv %uint %TileAOuter %uint_16 + %172 = OpCompositeExtract %uint %local_id 1 + %173 = OpIMul %uint %172 %171 + OpStore %t %106 + OpBranch %175 + %175 = OpLabel + OpLoopMerge %176 %177 None OpBranch %178 %178 = OpLabel - %331 = OpLoad %uint %t - %332 = OpIAdd %uint %331 %uint_1 - OpStore %t %332 + %180 = OpLoad %uint %t + %181 = OpULessThan %bool %180 %141 + %179 = OpLogicalNot %bool %181 + OpSelectionMerge %182 None + OpBranchConditional %179 %183 %182 + %183 = OpLabel OpBranch %176 + %182 = OpLabel + OpStore %innerRow %106 + OpBranch %185 + %185 = OpLabel + OpLoopMerge %186 %187 None + OpBranch %188 + %188 = OpLabel + %190 = OpLoad %uint %innerRow + %191 = OpULessThan %bool %190 %RowPerThread + %189 = OpLogicalNot %bool %191 + OpSelectionMerge %192 None + OpBranchConditional %189 %193 %192 + %193 = OpLabel + OpBranch %186 + %192 = OpLabel + OpStore %innerCol %106 + OpBranch %195 + %195 = OpLabel + OpLoopMerge %196 %197 None + OpBranch %198 + %198 = OpLabel + %200 = OpLoad %uint %innerCol + %201 = OpULessThan %bool %200 %168 + %199 = OpLogicalNot %bool %201 + OpSelectionMerge %202 None + OpBranchConditional %199 %203 %202 + %203 = OpLabel + OpBranch %196 + %202 = OpLabel + %204 = OpLoad %uint %innerRow + %205 = OpIAdd %uint %130 %204 + %206 = OpLoad %uint %innerCol + %207 = OpIAdd %uint %170 %206 + %209 = OpLoad %uint %innerRow + %210 = OpIAdd %uint %134 %209 + %211 = OpLoad %uint %t + %212 = OpIMul %uint %211 %TileAOuter + %213 = OpIAdd %uint %212 %207 + %208 = OpFunctionCall %float %mm_readA %210 %213 + %214 = OpAccessChain %_ptr_Workgroup_float %mm_Asub %205 %207 + OpStore %214 %208 + OpBranch %197 + %197 = OpLabel + %215 = OpLoad %uint %innerCol + %216 = OpIAdd %uint %215 %uint_1 + OpStore %innerCol %216 + OpBranch %195 + %196 = OpLabel + OpBranch %187 + %187 = OpLabel + %217 = OpLoad %uint %innerRow + %218 = OpIAdd %uint %217 %uint_1 + OpStore %innerRow %218 + OpBranch %185 + %186 = OpLabel + OpStore %innerRow_0 %106 + OpBranch %220 + %220 = OpLabel + OpLoopMerge %221 %222 None + OpBranch %223 + %223 = OpLabel + %225 = OpLoad %uint %innerRow_0 + %226 = OpULessThan %bool %225 %171 + %224 = OpLogicalNot %bool %226 + OpSelectionMerge %227 None + OpBranchConditional %224 %228 %227 + %228 = OpLabel + OpBranch %221 + %227 = OpLabel + OpStore %innerCol_0 %106 + OpBranch %230 + %230 = OpLabel + OpLoopMerge %231 %232 None + OpBranch %233 + %233 = OpLabel + %235 = OpLoad %uint %innerCol_0 + %236 = OpULessThan %bool %235 %RowPerThread + %234 = OpLogicalNot %bool %236 + OpSelectionMerge %237 None + OpBranchConditional %234 %238 %237 + %238 = OpLabel + OpBranch %231 + %237 = OpLabel + %239 = OpLoad %uint %innerRow_0 + %240 = OpIAdd %uint %173 %239 + %241 = OpLoad %uint %innerCol_0 + %242 = OpIAdd %uint %132 %241 + %244 = OpLoad %uint %t + %245 = OpIMul %uint %244 %TileAOuter + %246 = OpIAdd %uint %245 %240 + %247 = OpLoad %uint %innerCol_0 + %248 = OpIAdd %uint %136 %247 + %243 = OpFunctionCall %float %mm_readB %246 %248 + %249 = OpLoad %uint %innerCol_0 + %250 = OpAccessChain %_ptr_Workgroup_float %mm_Bsub %249 %242 + OpStore %250 %243 + OpBranch %232 + %232 = OpLabel + %251 = OpLoad %uint %innerCol_0 + %252 = OpIAdd %uint %251 %uint_1 + OpStore %innerCol_0 %252 + OpBranch %230 + %231 = OpLabel + OpBranch %222 + %222 = OpLabel + %253 = OpLoad %uint %innerRow_0 + %254 = OpIAdd %uint %253 %uint_1 + OpStore %innerRow_0 %254 + OpBranch %220 + %221 = OpLabel + OpControlBarrier %uint_2 %uint_2 %uint_264 + OpStore %k %106 + OpBranch %257 + %257 = OpLabel + OpLoopMerge %258 %259 None + OpBranch %260 + %260 = OpLabel + %262 = OpLoad %uint %k + %263 = OpULessThan %bool %262 %TileAOuter + %261 = OpLogicalNot %bool %263 + OpSelectionMerge %264 None + OpBranchConditional %261 %265 %264 + %265 = OpLabel + OpBranch %258 + %264 = OpLabel + OpStore %inner %106 + OpBranch %267 + %267 = OpLabel + OpLoopMerge %268 %269 None + OpBranch %270 + %270 = OpLabel + %272 = OpLoad %uint %inner + %273 = OpULessThan %bool %272 %RowPerThread + %271 = OpLogicalNot %bool %273 + OpSelectionMerge %274 None + OpBranchConditional %271 %275 %274 + %275 = OpLabel + OpBranch %268 + %274 = OpLabel + %276 = OpLoad %uint %inner + %277 = OpAccessChain %_ptr_Function_float %BCached %276 + %278 = OpLoad %uint %k + %279 = OpLoad %uint %inner + %280 = OpIAdd %uint %132 %279 + %281 = OpAccessChain %_ptr_Workgroup_float %mm_Bsub %278 %280 + %282 = OpLoad %float %281 + OpStore %277 %282 + OpBranch %269 + %269 = OpLabel + %283 = OpLoad %uint %inner + %284 = OpIAdd %uint %283 %uint_1 + OpStore %inner %284 + OpBranch %267 + %268 = OpLabel + OpStore %innerRow_1 %106 + OpBranch %286 + %286 = OpLabel + OpLoopMerge %287 %288 None + OpBranch %289 + %289 = OpLabel + %291 = OpLoad %uint %innerRow_1 + %292 = OpULessThan %bool %291 %RowPerThread + %290 = OpLogicalNot %bool %292 + OpSelectionMerge %293 None + OpBranchConditional %290 %294 %293 + %294 = OpLabel + OpBranch %287 + %293 = OpLabel + %295 = OpLoad %uint %innerRow_1 + %296 = OpIAdd %uint %130 %295 + %297 = OpLoad %uint %k + %298 = OpAccessChain %_ptr_Workgroup_float %mm_Asub %296 %297 + %299 = OpLoad %float %298 + OpStore %ACached %299 + OpStore %innerCol_1 %106 + OpBranch %301 + %301 = OpLabel + OpLoopMerge %302 %303 None + OpBranch %304 + %304 = OpLabel + %306 = OpLoad %uint %innerCol_1 + %307 = OpULessThan %bool %306 %RowPerThread + %305 = OpLogicalNot %bool %307 + OpSelectionMerge %308 None + OpBranchConditional %305 %309 %308 + %309 = OpLabel + OpBranch %302 + %308 = OpLabel + %310 = OpLoad %uint %innerRow_1 + %311 = OpIMul %uint %310 %RowPerThread + %312 = OpLoad %uint %innerCol_1 + %313 = OpIAdd %uint %311 %312 + %314 = OpAccessChain %_ptr_Function_float %acc %313 + %315 = OpAccessChain %_ptr_Function_float %acc %313 + %316 = OpLoad %float %315 + %317 = OpLoad %float %ACached + %318 = OpLoad %uint %innerCol_1 + %319 = OpAccessChain %_ptr_Function_float %BCached %318 + %320 = OpLoad %float %319 + %321 = OpFMul %float %317 %320 + %322 = OpFAdd %float %316 %321 + OpStore %314 %322 + OpBranch %303 + %303 = OpLabel + %323 = OpLoad %uint %innerCol_1 + %324 = OpIAdd %uint %323 %uint_1 + OpStore %innerCol_1 %324 + OpBranch %301 + %302 = OpLabel + OpBranch %288 + %288 = OpLabel + %325 = OpLoad %uint %innerRow_1 + %326 = OpIAdd %uint %325 %uint_1 + OpStore %innerRow_1 %326 + OpBranch %286 + %287 = OpLabel + OpBranch %259 + %259 = OpLabel + %327 = OpLoad %uint %k + %328 = OpIAdd %uint %327 %uint_1 + OpStore %k %328 + OpBranch %257 + %258 = OpLabel + OpControlBarrier %uint_2 %uint_2 %uint_264 + OpBranch %177 %177 = OpLabel - OpStore %innerRow_2 %uint_0 - OpBranch %334 - %334 = OpLabel - OpLoopMerge %335 %336 None - OpBranch %337 - %337 = OpLabel - %339 = OpLoad %uint %innerRow_2 - %340 = OpULessThan %bool %339 %RowPerThread - %338 = OpLogicalNot %bool %340 - OpSelectionMerge %341 None - OpBranchConditional %338 %342 %341 - %342 = OpLabel - OpBranch %335 - %341 = OpLabel - OpStore %innerCol_2 %uint_0 - OpBranch %344 - %344 = OpLabel - OpLoopMerge %345 %346 None - OpBranch %347 - %347 = OpLabel - %349 = OpLoad %uint %innerCol_2 - %350 = OpULessThan %bool %349 %RowPerThread - %348 = OpLogicalNot %bool %350 - OpSelectionMerge %351 None - OpBranchConditional %348 %352 %351 - %352 = OpLabel - OpBranch %345 - %351 = OpLabel - %353 = OpLoad %uint %innerRow_2 - %354 = OpIMul %uint %353 %RowPerThread - %355 = OpLoad %uint %innerCol_2 - %356 = OpIAdd %uint %354 %355 - %358 = OpLoad %uint %innerRow_2 - %359 = OpIAdd %uint %135 %358 - %360 = OpLoad %uint %innerCol_2 - %361 = OpIAdd %uint %137 %360 - %362 = OpAccessChain %_ptr_Function_float %acc %356 - %363 = OpLoad %float %362 - %357 = OpFunctionCall %void %mm_write %359 %361 %363 - OpBranch %346 - %346 = OpLabel - %364 = OpLoad %uint %innerCol_2 - %365 = OpIAdd %uint %364 %uint_1 - OpStore %innerCol_2 %365 - OpBranch %344 - %345 = OpLabel + %330 = OpLoad %uint %t + %331 = OpIAdd %uint %330 %uint_1 + OpStore %t %331 + OpBranch %175 + %176 = OpLabel + OpStore %innerRow_2 %106 + OpBranch %333 + %333 = OpLabel + OpLoopMerge %334 %335 None OpBranch %336 %336 = OpLabel - %366 = OpLoad %uint %innerRow_2 - %367 = OpIAdd %uint %366 %uint_1 - OpStore %innerRow_2 %367 + %338 = OpLoad %uint %innerRow_2 + %339 = OpULessThan %bool %338 %RowPerThread + %337 = OpLogicalNot %bool %339 + OpSelectionMerge %340 None + OpBranchConditional %337 %341 %340 + %341 = OpLabel OpBranch %334 + %340 = OpLabel + OpStore %innerCol_2 %106 + OpBranch %343 + %343 = OpLabel + OpLoopMerge %344 %345 None + OpBranch %346 + %346 = OpLabel + %348 = OpLoad %uint %innerCol_2 + %349 = OpULessThan %bool %348 %RowPerThread + %347 = OpLogicalNot %bool %349 + OpSelectionMerge %350 None + OpBranchConditional %347 %351 %350 + %351 = OpLabel + OpBranch %344 + %350 = OpLabel + %352 = OpLoad %uint %innerRow_2 + %353 = OpIMul %uint %352 %RowPerThread + %354 = OpLoad %uint %innerCol_2 + %355 = OpIAdd %uint %353 %354 + %357 = OpLoad %uint %innerRow_2 + %358 = OpIAdd %uint %134 %357 + %359 = OpLoad %uint %innerCol_2 + %360 = OpIAdd %uint %136 %359 + %361 = OpAccessChain %_ptr_Function_float %acc %355 + %362 = OpLoad %float %361 + %356 = OpFunctionCall %void %mm_write %358 %360 %362 + OpBranch %345 + %345 = OpLabel + %363 = OpLoad %uint %innerCol_2 + %364 = OpIAdd %uint %363 %uint_1 + OpStore %innerCol_2 %364 + OpBranch %343 + %344 = OpLabel + OpBranch %335 %335 = OpLabel + %365 = OpLoad %uint %innerRow_2 + %366 = OpIAdd %uint %365 %uint_1 + OpStore %innerRow_2 %366 + OpBranch %333 + %334 = OpLabel OpReturn OpFunctionEnd - %main = OpFunction %void None %368 - %370 = OpLabel - %372 = OpLoad %v3uint %local_id_1 - %373 = OpLoad %v3uint %global_id_1 - %374 = OpLoad %uint %local_invocation_index_1 - %371 = OpFunctionCall %void %main_inner %372 %373 %374 + %main = OpFunction %void None %367 + %369 = OpLabel + %371 = OpLoad %v3uint %local_id_1 + %372 = OpLoad %v3uint %global_id_1 + %373 = OpLoad %uint %local_invocation_index_1 + %370 = OpFunctionCall %void %main_inner %371 %372 %373 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/922.wgsl.expected.spvasm b/test/tint/bug/tint/922.wgsl.expected.spvasm index bc29396019..a831e50872 100644 --- a/test/tint/bug/tint/922.wgsl.expected.spvasm +++ b/test/tint/bug/tint/922.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 387 +; Bound: 386 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -219,16 +219,15 @@ %203 = OpTypeFunction %Mat4x4_ %float %_ptr_Function_float = OpTypePointer Function %float %uint_0 = OpConstant %uint 0 - %float_0 = OpConstant %float 0 %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 - %227 = OpTypeFunction %Mat4x4_ %Mat4x3_ + %226 = OpTypeFunction %Mat4x4_ %Mat4x3_ %float_1 = OpConstant %float 1 - %245 = OpTypeFunction %Mat4x4_ %Mat4x2_ - %259 = OpTypeFunction %Mat4x3_ %float - %275 = OpTypeFunction %Mat4x3_ %Mat4x4_ + %244 = OpTypeFunction %Mat4x4_ %Mat4x2_ + %258 = OpTypeFunction %Mat4x3_ %float + %274 = OpTypeFunction %Mat4x3_ %Mat4x4_ %void = OpTypeVoid - %291 = OpTypeFunction %void + %290 = OpTypeFunction %void %_ptr_Function_v2float = OpTypePointer Function %v2float %int = OpTypeInt 32 1 %_ptr_Uniform_Mat4x3_ = OpTypePointer Uniform %Mat4x3_ @@ -236,10 +235,10 @@ %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %float_2 = OpConstant %float 2 %bool = OpTypeBool - %int_0 = OpConstant %int 0 + %341 = OpConstantNull %int %_ptr_Uniform_Mat4x2_ = OpTypePointer Uniform %Mat4x2_ %VertexOutput = OpTypeStruct %v4float %v2float %v4float - %362 = OpTypeFunction %VertexOutput %v3float %v2float %v4float %v3float %float + %361 = OpTypeFunction %VertexOutput %v3float %v2float %v4float %v3float %float %Mat4x3GetCol0_ = OpFunction %v3float None %54 %m = OpFunctionParameter %Mat4x3_ %57 = OpLabel @@ -412,211 +411,211 @@ OpStore %n1 %n %210 = OpLoad %float %n1 %212 = OpAccessChain %_ptr_Function_v4float %o %uint_0 - %214 = OpCompositeConstruct %v4float %210 %float_0 %float_0 %float_0 - OpStore %212 %214 - %215 = OpLoad %float %n1 - %216 = OpAccessChain %_ptr_Function_v4float %o %uint_1 - %217 = OpCompositeConstruct %v4float %float_0 %215 %float_0 %float_0 - OpStore %216 %217 - %218 = OpLoad %float %n1 - %220 = OpAccessChain %_ptr_Function_v4float %o %uint_2 - %221 = OpCompositeConstruct %v4float %float_0 %float_0 %218 %float_0 - OpStore %220 %221 - %222 = OpLoad %float %n1 - %224 = OpAccessChain %_ptr_Function_v4float %o %uint_3 - %225 = OpCompositeConstruct %v4float %float_0 %float_0 %float_0 %222 - OpStore %224 %225 - %226 = OpLoad %Mat4x4_ %o - OpReturnValue %226 + %213 = OpCompositeConstruct %v4float %210 %23 %23 %23 + OpStore %212 %213 + %214 = OpLoad %float %n1 + %215 = OpAccessChain %_ptr_Function_v4float %o %uint_1 + %216 = OpCompositeConstruct %v4float %23 %214 %23 %23 + OpStore %215 %216 + %217 = OpLoad %float %n1 + %219 = OpAccessChain %_ptr_Function_v4float %o %uint_2 + %220 = OpCompositeConstruct %v4float %23 %23 %217 %23 + OpStore %219 %220 + %221 = OpLoad %float %n1 + %223 = OpAccessChain %_ptr_Function_v4float %o %uint_3 + %224 = OpCompositeConstruct %v4float %23 %23 %23 %221 + OpStore %223 %224 + %225 = OpLoad %Mat4x4_ %o + OpReturnValue %225 OpFunctionEnd - %x_Mat4x4_1 = OpFunction %Mat4x4_ None %227 + %x_Mat4x4_1 = OpFunction %Mat4x4_ None %226 %m16 = OpFunctionParameter %Mat4x3_ - %230 = OpLabel + %229 = OpLabel %m17 = OpVariable %_ptr_Function_Mat4x3_ Function %60 %o1 = OpVariable %_ptr_Function_Mat4x4_ Function %120 OpStore %m17 %m16 - %233 = OpFunctionCall %Mat4x4_ %x_Mat4x4_ %float_1 - OpStore %o1 %233 - %235 = OpLoad %Mat4x3_ %m17 - %236 = OpAccessChain %_ptr_Function_v4float %o1 %uint_0 - %237 = OpCompositeExtract %v4float %235 0 - OpStore %236 %237 - %238 = OpLoad %Mat4x3_ %m17 - %239 = OpAccessChain %_ptr_Function_v4float %o1 %uint_1 - %240 = OpCompositeExtract %v4float %238 1 - OpStore %239 %240 - %241 = OpLoad %Mat4x3_ %m17 - %242 = OpAccessChain %_ptr_Function_v4float %o1 %uint_2 - %243 = OpCompositeExtract %v4float %241 2 - OpStore %242 %243 - %244 = OpLoad %Mat4x4_ %o1 - OpReturnValue %244 + %232 = OpFunctionCall %Mat4x4_ %x_Mat4x4_ %float_1 + OpStore %o1 %232 + %234 = OpLoad %Mat4x3_ %m17 + %235 = OpAccessChain %_ptr_Function_v4float %o1 %uint_0 + %236 = OpCompositeExtract %v4float %234 0 + OpStore %235 %236 + %237 = OpLoad %Mat4x3_ %m17 + %238 = OpAccessChain %_ptr_Function_v4float %o1 %uint_1 + %239 = OpCompositeExtract %v4float %237 1 + OpStore %238 %239 + %240 = OpLoad %Mat4x3_ %m17 + %241 = OpAccessChain %_ptr_Function_v4float %o1 %uint_2 + %242 = OpCompositeExtract %v4float %240 2 + OpStore %241 %242 + %243 = OpLoad %Mat4x4_ %o1 + OpReturnValue %243 OpFunctionEnd - %x_Mat4x4_2 = OpFunction %Mat4x4_ None %245 + %x_Mat4x4_2 = OpFunction %Mat4x4_ None %244 %m18 = OpFunctionParameter %Mat4x2_ - %248 = OpLabel + %247 = OpLabel %m19 = OpVariable %_ptr_Function_Mat4x2_ Function %167 %o2 = OpVariable %_ptr_Function_Mat4x4_ Function %120 OpStore %m19 %m18 - %251 = OpFunctionCall %Mat4x4_ %x_Mat4x4_ %float_1 - OpStore %o2 %251 - %252 = OpLoad %Mat4x2_ %m19 - %253 = OpAccessChain %_ptr_Function_v4float %o2 %uint_0 - %254 = OpCompositeExtract %v4float %252 0 - OpStore %253 %254 - %255 = OpLoad %Mat4x2_ %m19 - %256 = OpAccessChain %_ptr_Function_v4float %o2 %uint_1 - %257 = OpCompositeExtract %v4float %255 1 - OpStore %256 %257 - %258 = OpLoad %Mat4x4_ %o2 - OpReturnValue %258 + %250 = OpFunctionCall %Mat4x4_ %x_Mat4x4_ %float_1 + OpStore %o2 %250 + %251 = OpLoad %Mat4x2_ %m19 + %252 = OpAccessChain %_ptr_Function_v4float %o2 %uint_0 + %253 = OpCompositeExtract %v4float %251 0 + OpStore %252 %253 + %254 = OpLoad %Mat4x2_ %m19 + %255 = OpAccessChain %_ptr_Function_v4float %o2 %uint_1 + %256 = OpCompositeExtract %v4float %254 1 + OpStore %255 %256 + %257 = OpLoad %Mat4x4_ %o2 + OpReturnValue %257 OpFunctionEnd - %x_Mat4x3_ = OpFunction %Mat4x3_ None %259 + %x_Mat4x3_ = OpFunction %Mat4x3_ None %258 %n2 = OpFunctionParameter %float - %262 = OpLabel + %261 = OpLabel %n3 = OpVariable %_ptr_Function_float Function %23 %o3 = OpVariable %_ptr_Function_Mat4x3_ Function %60 OpStore %n3 %n2 - %265 = OpLoad %float %n3 - %266 = OpAccessChain %_ptr_Function_v4float %o3 %uint_0 - %267 = OpCompositeConstruct %v4float %265 %float_0 %float_0 %float_0 - OpStore %266 %267 - %268 = OpLoad %float %n3 - %269 = OpAccessChain %_ptr_Function_v4float %o3 %uint_1 - %270 = OpCompositeConstruct %v4float %float_0 %268 %float_0 %float_0 - OpStore %269 %270 - %271 = OpLoad %float %n3 - %272 = OpAccessChain %_ptr_Function_v4float %o3 %uint_2 - %273 = OpCompositeConstruct %v4float %float_0 %float_0 %271 %float_0 - OpStore %272 %273 - %274 = OpLoad %Mat4x3_ %o3 - OpReturnValue %274 + %264 = OpLoad %float %n3 + %265 = OpAccessChain %_ptr_Function_v4float %o3 %uint_0 + %266 = OpCompositeConstruct %v4float %264 %23 %23 %23 + OpStore %265 %266 + %267 = OpLoad %float %n3 + %268 = OpAccessChain %_ptr_Function_v4float %o3 %uint_1 + %269 = OpCompositeConstruct %v4float %23 %267 %23 %23 + OpStore %268 %269 + %270 = OpLoad %float %n3 + %271 = OpAccessChain %_ptr_Function_v4float %o3 %uint_2 + %272 = OpCompositeConstruct %v4float %23 %23 %270 %23 + OpStore %271 %272 + %273 = OpLoad %Mat4x3_ %o3 + OpReturnValue %273 OpFunctionEnd - %x_Mat4x3_1 = OpFunction %Mat4x3_ None %275 + %x_Mat4x3_1 = OpFunction %Mat4x3_ None %274 %m20 = OpFunctionParameter %Mat4x4_ - %278 = OpLabel + %277 = OpLabel %m21 = OpVariable %_ptr_Function_Mat4x4_ Function %120 %o4 = OpVariable %_ptr_Function_Mat4x3_ Function %60 OpStore %m21 %m20 - %281 = OpLoad %Mat4x4_ %m21 - %282 = OpAccessChain %_ptr_Function_v4float %o4 %uint_0 - %283 = OpCompositeExtract %v4float %281 0 - OpStore %282 %283 - %284 = OpLoad %Mat4x4_ %m21 - %285 = OpAccessChain %_ptr_Function_v4float %o4 %uint_1 - %286 = OpCompositeExtract %v4float %284 1 - OpStore %285 %286 - %287 = OpLoad %Mat4x4_ %m21 - %288 = OpAccessChain %_ptr_Function_v4float %o4 %uint_2 - %289 = OpCompositeExtract %v4float %287 2 - OpStore %288 %289 - %290 = OpLoad %Mat4x3_ %o4 - OpReturnValue %290 + %280 = OpLoad %Mat4x4_ %m21 + %281 = OpAccessChain %_ptr_Function_v4float %o4 %uint_0 + %282 = OpCompositeExtract %v4float %280 0 + OpStore %281 %282 + %283 = OpLoad %Mat4x4_ %m21 + %284 = OpAccessChain %_ptr_Function_v4float %o4 %uint_1 + %285 = OpCompositeExtract %v4float %283 1 + OpStore %284 %285 + %286 = OpLoad %Mat4x4_ %m21 + %287 = OpAccessChain %_ptr_Function_v4float %o4 %uint_2 + %288 = OpCompositeExtract %v4float %286 2 + OpStore %287 %288 + %289 = OpLoad %Mat4x3_ %o4 + OpReturnValue %289 OpFunctionEnd - %main1 = OpFunction %void None %291 - %294 = OpLabel + %main1 = OpFunction %void None %290 + %293 = OpLabel %t_PosMtx = OpVariable %_ptr_Function_Mat4x3_ Function %60 %t_TexSpaceCoord = OpVariable %_ptr_Function_v2float Function %19 - %298 = OpLoad %float %a_PosMtxIdx1 - %299 = OpConvertFToS %int %298 - %302 = OpAccessChain %_ptr_Uniform_Mat4x3_ %global2 %uint_0 %299 - %303 = OpLoad %Mat4x3_ %302 - OpStore %t_PosMtx %303 - %304 = OpLoad %Mat4x3_ %t_PosMtx - %305 = OpFunctionCall %Mat4x4_ %x_Mat4x4_1 %304 - %306 = OpLoad %v3float %a_Position1 - %307 = OpLoad %Mat4x3_ %t_PosMtx - %308 = OpFunctionCall %Mat4x4_ %x_Mat4x4_1 %307 - %309 = OpLoad %v3float %a_Position1 - %311 = OpCompositeExtract %float %309 0 - %312 = OpCompositeExtract %float %309 1 - %313 = OpCompositeExtract %float %309 2 - %314 = OpCompositeConstruct %v4float %311 %312 %313 %float_1 - %310 = OpFunctionCall %v4float %Mul %308 %314 - %316 = OpAccessChain %_ptr_Uniform_Mat4x4_ %global %uint_0 - %317 = OpLoad %Mat4x4_ %316 - %318 = OpLoad %Mat4x3_ %t_PosMtx - %319 = OpFunctionCall %Mat4x4_ %x_Mat4x4_1 %318 - %320 = OpLoad %v3float %a_Position1 - %321 = OpLoad %Mat4x3_ %t_PosMtx - %322 = OpFunctionCall %Mat4x4_ %x_Mat4x4_1 %321 - %323 = OpLoad %v3float %a_Position1 - %325 = OpCompositeExtract %float %323 0 - %326 = OpCompositeExtract %float %323 1 - %327 = OpCompositeExtract %float %323 2 - %328 = OpCompositeConstruct %v4float %325 %326 %327 %float_1 - %324 = OpFunctionCall %v4float %Mul %322 %328 - %329 = OpFunctionCall %v4float %Mul %317 %324 - OpStore %gl_Position %329 - %330 = OpLoad %v4float %a_Color1 - OpStore %v_Color %330 - %332 = OpAccessChain %_ptr_Uniform_v4float %global1 %uint_1 - %333 = OpLoad %v4float %332 - %334 = OpCompositeExtract %float %333 0 - %336 = OpFOrdEqual %bool %334 %float_2 - OpSelectionMerge %338 None - OpBranchConditional %336 %339 %340 - %339 = OpLabel - %341 = OpLoad %v3float %a_Normal1 - %344 = OpAccessChain %_ptr_Uniform_Mat4x2_ %global1 %uint_0 %int_0 - %345 = OpLoad %Mat4x2_ %344 - %346 = OpLoad %v3float %a_Normal1 - %348 = OpCompositeExtract %float %346 0 - %349 = OpCompositeExtract %float %346 1 - %350 = OpCompositeExtract %float %346 2 - %351 = OpCompositeConstruct %v4float %348 %349 %350 %float_1 - %347 = OpFunctionCall %v2float %Mul2 %345 %351 - %352 = OpVectorShuffle %v2float %347 %347 0 1 - OpStore %v_TexCoord %352 - OpReturn - %340 = OpLabel - %353 = OpLoad %v2float %a_UV1 - %354 = OpAccessChain %_ptr_Uniform_Mat4x2_ %global1 %uint_0 %int_0 - %355 = OpLoad %Mat4x2_ %354 - %356 = OpLoad %v2float %a_UV1 - %358 = OpCompositeExtract %float %356 0 - %359 = OpCompositeExtract %float %356 1 - %360 = OpCompositeConstruct %v4float %358 %359 %float_1 %float_1 - %357 = OpFunctionCall %v2float %Mul2 %355 %360 - %361 = OpVectorShuffle %v2float %357 %357 0 1 - OpStore %v_TexCoord %361 - OpReturn + %297 = OpLoad %float %a_PosMtxIdx1 + %298 = OpConvertFToS %int %297 + %301 = OpAccessChain %_ptr_Uniform_Mat4x3_ %global2 %uint_0 %298 + %302 = OpLoad %Mat4x3_ %301 + OpStore %t_PosMtx %302 + %303 = OpLoad %Mat4x3_ %t_PosMtx + %304 = OpFunctionCall %Mat4x4_ %x_Mat4x4_1 %303 + %305 = OpLoad %v3float %a_Position1 + %306 = OpLoad %Mat4x3_ %t_PosMtx + %307 = OpFunctionCall %Mat4x4_ %x_Mat4x4_1 %306 + %308 = OpLoad %v3float %a_Position1 + %310 = OpCompositeExtract %float %308 0 + %311 = OpCompositeExtract %float %308 1 + %312 = OpCompositeExtract %float %308 2 + %313 = OpCompositeConstruct %v4float %310 %311 %312 %float_1 + %309 = OpFunctionCall %v4float %Mul %307 %313 + %315 = OpAccessChain %_ptr_Uniform_Mat4x4_ %global %uint_0 + %316 = OpLoad %Mat4x4_ %315 + %317 = OpLoad %Mat4x3_ %t_PosMtx + %318 = OpFunctionCall %Mat4x4_ %x_Mat4x4_1 %317 + %319 = OpLoad %v3float %a_Position1 + %320 = OpLoad %Mat4x3_ %t_PosMtx + %321 = OpFunctionCall %Mat4x4_ %x_Mat4x4_1 %320 + %322 = OpLoad %v3float %a_Position1 + %324 = OpCompositeExtract %float %322 0 + %325 = OpCompositeExtract %float %322 1 + %326 = OpCompositeExtract %float %322 2 + %327 = OpCompositeConstruct %v4float %324 %325 %326 %float_1 + %323 = OpFunctionCall %v4float %Mul %321 %327 + %328 = OpFunctionCall %v4float %Mul %316 %323 + OpStore %gl_Position %328 + %329 = OpLoad %v4float %a_Color1 + OpStore %v_Color %329 + %331 = OpAccessChain %_ptr_Uniform_v4float %global1 %uint_1 + %332 = OpLoad %v4float %331 + %333 = OpCompositeExtract %float %332 0 + %335 = OpFOrdEqual %bool %333 %float_2 + OpSelectionMerge %337 None + OpBranchConditional %335 %338 %339 %338 = OpLabel + %340 = OpLoad %v3float %a_Normal1 + %343 = OpAccessChain %_ptr_Uniform_Mat4x2_ %global1 %uint_0 %341 + %344 = OpLoad %Mat4x2_ %343 + %345 = OpLoad %v3float %a_Normal1 + %347 = OpCompositeExtract %float %345 0 + %348 = OpCompositeExtract %float %345 1 + %349 = OpCompositeExtract %float %345 2 + %350 = OpCompositeConstruct %v4float %347 %348 %349 %float_1 + %346 = OpFunctionCall %v2float %Mul2 %344 %350 + %351 = OpVectorShuffle %v2float %346 %346 0 1 + OpStore %v_TexCoord %351 + OpReturn + %339 = OpLabel + %352 = OpLoad %v2float %a_UV1 + %353 = OpAccessChain %_ptr_Uniform_Mat4x2_ %global1 %uint_0 %341 + %354 = OpLoad %Mat4x2_ %353 + %355 = OpLoad %v2float %a_UV1 + %357 = OpCompositeExtract %float %355 0 + %358 = OpCompositeExtract %float %355 1 + %359 = OpCompositeConstruct %v4float %357 %358 %float_1 %float_1 + %356 = OpFunctionCall %v2float %Mul2 %354 %359 + %360 = OpVectorShuffle %v2float %356 %356 0 1 + OpStore %v_TexCoord %360 + OpReturn + %337 = OpLabel OpReturn OpFunctionEnd - %main_inner = OpFunction %VertexOutput None %362 + %main_inner = OpFunction %VertexOutput None %361 %a_Position = OpFunctionParameter %v3float %a_UV = OpFunctionParameter %v2float %a_Color = OpFunctionParameter %v4float %a_Normal = OpFunctionParameter %v3float %a_PosMtxIdx = OpFunctionParameter %float - %370 = OpLabel + %369 = OpLabel OpStore %a_Position1 %a_Position OpStore %a_UV1 %a_UV OpStore %a_Color1 %a_Color OpStore %a_Normal1 %a_Normal OpStore %a_PosMtxIdx1 %a_PosMtxIdx - %371 = OpFunctionCall %void %main1 - %372 = OpLoad %v4float %v_Color - %373 = OpLoad %v2float %v_TexCoord - %374 = OpLoad %v4float %gl_Position - %375 = OpCompositeConstruct %VertexOutput %372 %373 %374 - OpReturnValue %375 + %370 = OpFunctionCall %void %main1 + %371 = OpLoad %v4float %v_Color + %372 = OpLoad %v2float %v_TexCoord + %373 = OpLoad %v4float %gl_Position + %374 = OpCompositeConstruct %VertexOutput %371 %372 %373 + OpReturnValue %374 OpFunctionEnd - %main = OpFunction %void None %291 - %377 = OpLabel - %379 = OpLoad %v3float %a_Position_1 - %380 = OpLoad %v2float %a_UV_1 - %381 = OpLoad %v4float %a_Color_1 - %382 = OpLoad %v3float %a_Normal_1 - %383 = OpLoad %float %a_PosMtxIdx_1 - %378 = OpFunctionCall %VertexOutput %main_inner %379 %380 %381 %382 %383 - %384 = OpCompositeExtract %v4float %378 0 - OpStore %v_Color_1 %384 - %385 = OpCompositeExtract %v2float %378 1 - OpStore %v_TexCoord_1 %385 - %386 = OpCompositeExtract %v4float %378 2 - OpStore %member_1 %386 + %main = OpFunction %void None %290 + %376 = OpLabel + %378 = OpLoad %v3float %a_Position_1 + %379 = OpLoad %v2float %a_UV_1 + %380 = OpLoad %v4float %a_Color_1 + %381 = OpLoad %v3float %a_Normal_1 + %382 = OpLoad %float %a_PosMtxIdx_1 + %377 = OpFunctionCall %VertexOutput %main_inner %378 %379 %380 %381 %382 + %383 = OpCompositeExtract %v4float %377 0 + OpStore %v_Color_1 %383 + %384 = OpCompositeExtract %v2float %377 1 + OpStore %v_TexCoord_1 %384 + %385 = OpCompositeExtract %v4float %377 2 + OpStore %member_1 %385 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/926.wgsl.expected.spvasm b/test/tint/bug/tint/926.wgsl.expected.spvasm index 8b29d2780e..f3853ec4bb 100644 --- a/test/tint/bug/tint/926.wgsl.expected.spvasm +++ b/test/tint/bug/tint/926.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 27 +; Bound: 28 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -27,25 +27,26 @@ %DrawIndirectArgs = OpTypeStruct %uint %_ptr_StorageBuffer_DrawIndirectArgs = OpTypePointer StorageBuffer %DrawIndirectArgs %drawOut = OpVariable %_ptr_StorageBuffer_DrawIndirectArgs StorageBuffer - %uint_0 = OpConstant %uint 0 + %8 = OpConstantNull %uint %_ptr_Private_uint = OpTypePointer Private %uint - %cubeVerts = OpVariable %_ptr_Private_uint Private %uint_0 + %cubeVerts = OpVariable %_ptr_Private_uint Private %8 %void = OpTypeVoid %11 = OpTypeFunction %void %v3uint %uint_1 = OpConstant %uint 1 + %uint_0 = OpConstant %uint 0 %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint - %22 = OpTypeFunction %void + %23 = OpTypeFunction %void %computeMain_inner = OpFunction %void None %11 %global_id = OpFunctionParameter %v3uint %15 = OpLabel - %20 = OpAccessChain %_ptr_StorageBuffer_uint %drawOut %uint_0 - %21 = OpLoad %uint %cubeVerts - %16 = OpAtomicIAdd %uint %20 %uint_1 %uint_0 %21 + %21 = OpAccessChain %_ptr_StorageBuffer_uint %drawOut %uint_0 + %22 = OpLoad %uint %cubeVerts + %16 = OpAtomicIAdd %uint %21 %uint_1 %uint_0 %22 OpReturn OpFunctionEnd -%computeMain = OpFunction %void None %22 - %24 = OpLabel - %26 = OpLoad %v3uint %global_id_1 - %25 = OpFunctionCall %void %computeMain_inner %26 +%computeMain = OpFunction %void None %23 + %25 = OpLabel + %27 = OpLoad %v3uint %global_id_1 + %26 = OpFunctionCall %void %computeMain_inner %27 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/942.wgsl.expected.spvasm b/test/tint/bug/tint/942.wgsl.expected.spvasm index 0111307583..25417c32a2 100644 --- a/test/tint/bug/tint/942.wgsl.expected.spvasm +++ b/test/tint/bug/tint/942.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 259 +; Bound: 258 ; Schema: 0 OpCapability Shader OpCapability ImageQuery @@ -106,7 +106,7 @@ %uint_1 = OpConstant %uint 1 %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 - %int_0 = OpConstant %int 0 + %76 = OpConstantNull %int %v2uint = OpTypeVector %uint 2 %85 = OpConstantComposite %v2uint %uint_4 %uint_1 %_ptr_Function_v2int = OpTypePointer Function %v2int @@ -116,12 +116,11 @@ %v2float = OpTypeVector %float 2 %float_0_25 = OpConstant %float 0.25 %143 = OpConstantComposite %v2float %float_0_25 %float_0_25 - %float_0 = OpConstant %float 0 + %147 = OpConstantNull %float %v2bool = OpTypeVector %bool 2 - %207 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %_ptr_Function_v3float = OpTypePointer Function %v3float %float_1 = OpConstant %float 1 - %252 = OpTypeFunction %void + %251 = OpTypeFunction %void %main_inner = OpFunction %void None %31 %WorkGroupID = OpFunctionParameter %v3uint %LocalInvocationID = OpFunctionParameter %v3uint @@ -170,7 +169,7 @@ %70 = OpISub %uint %68 %uint_1 %71 = OpUDiv %uint %70 %uint_2 %75 = OpLoad %16 %inputTex - %72 = OpImageQuerySizeLod %v2int %75 %int_0 + %72 = OpImageQuerySizeLod %v2int %75 %76 %79 = OpVectorShuffle %v2uint %WorkGroupID %WorkGroupID 0 1 %80 = OpAccessChain %_ptr_Uniform_uint %params %uint_1 %81 = OpLoad %uint %80 @@ -181,9 +180,9 @@ %87 = OpIAdd %v2uint %83 %86 %77 = OpBitcast %v2int %87 %88 = OpBitcast %int %71 - %89 = OpCompositeConstruct %v2int %88 %int_0 + %89 = OpCompositeConstruct %v2int %88 %76 %90 = OpISub %v2int %77 %89 - OpStore %r %uint_0 + OpStore %r %40 OpBranch %92 %92 = OpLabel OpLoopMerge %93 %94 None @@ -197,7 +196,7 @@ %100 = OpLabel OpBranch %93 %99 = OpLabel - OpStore %c %uint_0 + OpStore %c %40 OpBranch %102 %102 = OpLabel OpLoopMerge %103 %104 None @@ -220,7 +219,7 @@ OpStore %loadIndex %116 %120 = OpAccessChain %_ptr_Uniform_uint %flip %uint_0 %121 = OpLoad %uint %120 - %122 = OpINotEqual %bool %121 %uint_0 + %122 = OpINotEqual %bool %121 %40 OpSelectionMerge %123 None OpBranchConditional %122 %124 %123 %124 = OpLabel @@ -243,7 +242,7 @@ %144 = OpFAdd %v2float %139 %143 %145 = OpConvertSToF %v2float %72 %146 = OpFDiv %v2float %144 %145 - %133 = OpImageSampleExplicitLod %v4float %138 %146 Lod %float_0 + %133 = OpImageSampleExplicitLod %v4float %138 %146 Lod %147 %148 = OpVectorShuffle %v3float %133 %133 0 1 2 OpStore %132 %148 OpBranch %104 @@ -261,7 +260,7 @@ OpBranch %92 %93 = OpLabel OpControlBarrier %uint_2 %uint_2 %uint_264 - OpStore %r_0 %uint_0 + OpStore %r_0 %40 OpBranch %155 %155 = OpLabel OpLoopMerge %156 %157 None @@ -275,7 +274,7 @@ %163 = OpLabel OpBranch %156 %162 = OpLabel - OpStore %c_0 %uint_0 + OpStore %c_0 %40 OpBranch %165 %165 = OpLabel OpLoopMerge %166 %167 None @@ -298,7 +297,7 @@ OpStore %writeIndex %179 %181 = OpAccessChain %_ptr_Uniform_uint %flip %uint_0 %182 = OpLoad %uint %181 - %183 = OpINotEqual %bool %182 %uint_0 + %183 = OpINotEqual %bool %182 %40 OpSelectionMerge %184 None OpBranchConditional %183 %185 %184 %185 = OpLabel @@ -332,77 +331,77 @@ OpSelectionMerge %205 None OpBranchConditional %204 %206 %205 %206 = OpLabel - OpStore %acc %207 - OpStore %f %uint_0 - OpBranch %211 - %211 = OpLabel - OpLoopMerge %212 %213 None - OpBranch %214 - %214 = OpLabel - %216 = OpLoad %uint %f - %217 = OpAccessChain %_ptr_Uniform_uint %params %uint_0 - %218 = OpLoad %uint %217 - %219 = OpULessThan %bool %216 %218 - %215 = OpLogicalNot %bool %219 - OpSelectionMerge %220 None - OpBranchConditional %215 %221 %220 - %221 = OpLabel - OpBranch %212 - %220 = OpLabel - %222 = OpLoad %uint %f - %223 = OpIAdd %uint %191 %222 - %224 = OpISub %uint %223 %71 - OpStore %i %224 - %226 = OpLoad %v3float %acc - %229 = OpAccessChain %_ptr_Uniform_uint %params %uint_0 - %230 = OpLoad %uint %229 - %228 = OpConvertUToF %float %230 - %231 = OpFDiv %float %float_1 %228 - %232 = OpLoad %uint %r_0 - %233 = OpLoad %uint %i - %234 = OpAccessChain %_ptr_Workgroup_v3float %tile %232 %233 - %235 = OpLoad %v3float %234 - %236 = OpVectorTimesScalar %v3float %235 %231 - %237 = OpFAdd %v3float %226 %236 - OpStore %acc %237 + OpStore %acc %58 + OpStore %f %40 + OpBranch %210 + %210 = OpLabel + OpLoopMerge %211 %212 None OpBranch %213 %213 = OpLabel - %238 = OpLoad %uint %f - %239 = OpIAdd %uint %238 %uint_1 - OpStore %f %239 + %215 = OpLoad %uint %f + %216 = OpAccessChain %_ptr_Uniform_uint %params %uint_0 + %217 = OpLoad %uint %216 + %218 = OpULessThan %bool %215 %217 + %214 = OpLogicalNot %bool %218 + OpSelectionMerge %219 None + OpBranchConditional %214 %220 %219 + %220 = OpLabel OpBranch %211 + %219 = OpLabel + %221 = OpLoad %uint %f + %222 = OpIAdd %uint %191 %221 + %223 = OpISub %uint %222 %71 + OpStore %i %223 + %225 = OpLoad %v3float %acc + %228 = OpAccessChain %_ptr_Uniform_uint %params %uint_0 + %229 = OpLoad %uint %228 + %227 = OpConvertUToF %float %229 + %230 = OpFDiv %float %float_1 %227 + %231 = OpLoad %uint %r_0 + %232 = OpLoad %uint %i + %233 = OpAccessChain %_ptr_Workgroup_v3float %tile %231 %232 + %234 = OpLoad %v3float %233 + %235 = OpVectorTimesScalar %v3float %234 %230 + %236 = OpFAdd %v3float %225 %235 + OpStore %acc %236 + OpBranch %212 %212 = OpLabel - %241 = OpLoad %20 %outputTex - %242 = OpLoad %v2int %writeIndex - %243 = OpLoad %v3float %acc - %244 = OpCompositeExtract %float %243 0 - %245 = OpCompositeExtract %float %243 1 - %246 = OpCompositeExtract %float %243 2 - %247 = OpCompositeConstruct %v4float %244 %245 %246 %float_1 - OpImageWrite %241 %242 %247 + %237 = OpLoad %uint %f + %238 = OpIAdd %uint %237 %uint_1 + OpStore %f %238 + OpBranch %210 + %211 = OpLabel + %240 = OpLoad %20 %outputTex + %241 = OpLoad %v2int %writeIndex + %242 = OpLoad %v3float %acc + %243 = OpCompositeExtract %float %242 0 + %244 = OpCompositeExtract %float %242 1 + %245 = OpCompositeExtract %float %242 2 + %246 = OpCompositeConstruct %v4float %243 %244 %245 %float_1 + OpImageWrite %240 %241 %246 OpBranch %205 %205 = OpLabel OpBranch %167 %167 = OpLabel - %248 = OpLoad %uint %c_0 - %249 = OpIAdd %uint %248 %uint_1 - OpStore %c_0 %249 + %247 = OpLoad %uint %c_0 + %248 = OpIAdd %uint %247 %uint_1 + OpStore %c_0 %248 OpBranch %165 %166 = OpLabel OpBranch %157 %157 = OpLabel - %250 = OpLoad %uint %r_0 - %251 = OpIAdd %uint %250 %uint_1 - OpStore %r_0 %251 + %249 = OpLoad %uint %r_0 + %250 = OpIAdd %uint %249 %uint_1 + OpStore %r_0 %250 OpBranch %155 %156 = OpLabel OpReturn OpFunctionEnd - %main = OpFunction %void None %252 - %254 = OpLabel - %256 = OpLoad %v3uint %WorkGroupID_1 - %257 = OpLoad %v3uint %LocalInvocationID_1 - %258 = OpLoad %uint %local_invocation_index_1 - %255 = OpFunctionCall %void %main_inner %256 %257 %258 + %main = OpFunction %void None %251 + %253 = OpLabel + %255 = OpLoad %v3uint %WorkGroupID_1 + %256 = OpLoad %v3uint %LocalInvocationID_1 + %257 = OpLoad %uint %local_invocation_index_1 + %254 = OpFunctionCall %void %main_inner %255 %256 %257 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/943.spvasm.expected.spvasm b/test/tint/bug/tint/943.spvasm.expected.spvasm index 95719122ce..f177fa1d19 100644 --- a/test/tint/bug/tint/943.spvasm.expected.spvasm +++ b/test/tint/bug/tint/943.spvasm.expected.spvasm @@ -4,7 +4,7 @@ note: reading from module-scope private variable 'dimInner_1' may result in a no ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 633 +; Bound: 630 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -210,43 +210,40 @@ note: reading from module-scope private variable 'dimInner_1' may result in a no %45 = OpTypeFunction %bool %_ptr_Function_v2int %_ptr_Function_v2int %_ptr_Function_bool = OpTypePointer Function %bool %54 = OpConstantNull %bool - %int_0 = OpConstant %int 0 - %60 = OpConstantComposite %v2int %int_0 %int_0 + %59 = OpConstantNull %v2int %v2bool = OpTypeVector %bool 2 %_ptr_Function_int = OpTypePointer Function %int - %73 = OpTypeFunction %float %_ptr_Function_int %_ptr_Function_int - %81 = OpConstantNull %v2int + %72 = OpTypeFunction %float %_ptr_Function_int %_ptr_Function_int %_ptr_Function_float = OpTypePointer Function %float - %85 = OpConstantNull %float + %83 = OpConstantNull %float %_ptr_Uniform_int = OpTypePointer Uniform %int %uint_2 = OpConstant %uint 2 %uint_0 = OpConstant %uint 0 %_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float - %float_0 = OpConstant %float 0 %_ptr_Function_v3int = OpTypePointer Function %v3int - %165 = OpTypeFunction %int %_ptr_Function_v3int + %162 = OpTypeFunction %int %_ptr_Function_v3int %uint_4 = OpConstant %uint 4 %v3float = OpTypeVector %float 3 %int_1 = OpConstant %int 1 %void = OpTypeVoid - %184 = OpTypeFunction %void %_ptr_Function_int %_ptr_Function_float - %195 = OpTypeFunction %void %_ptr_Function_int %_ptr_Function_int %_ptr_Function_int %_ptr_Function_float - %204 = OpConstantNull %v3int - %222 = OpTypeFunction %void %_ptr_Function_int %_ptr_Function_int %_ptr_Function_float - %251 = OpTypeFunction %void %_ptr_Function_int %_ptr_Function_int %_ptr_Function_int + %181 = OpTypeFunction %void %_ptr_Function_int %_ptr_Function_float + %192 = OpTypeFunction %void %_ptr_Function_int %_ptr_Function_int %_ptr_Function_int %_ptr_Function_float + %201 = OpConstantNull %v3int + %219 = OpTypeFunction %void %_ptr_Function_int %_ptr_Function_int %_ptr_Function_float + %248 = OpTypeFunction %void %_ptr_Function_int %_ptr_Function_int %_ptr_Function_int %_arr__arr_float_uint_1_uint_1 = OpTypeArray %_arr_float_uint_1 %uint_1 %_ptr_Function__arr__arr_float_uint_1_uint_1 = OpTypePointer Function %_arr__arr_float_uint_1_uint_1 - %267 = OpConstantNull %_arr__arr_float_uint_1_uint_1 + %264 = OpConstantNull %_arr__arr_float_uint_1_uint_1 %_ptr_Function__arr_float_uint_1 = OpTypePointer Function %_arr_float_uint_1 - %287 = OpConstantNull %_arr_float_uint_1 + %284 = OpConstantNull %_arr_float_uint_1 %_ptr_Private_uint = OpTypePointer Private %uint %int_64 = OpConstant %int 64 %_ptr_Workgroup_float = OpTypePointer Workgroup %float %uint_264 = OpConstant %uint 264 - %575 = OpTypeFunction %void - %597 = OpTypeFunction %void %v3uint %v3uint %uint + %572 = OpTypeFunction %void + %594 = OpTypeFunction %void %v3uint %v3uint %uint %_ptr_Function_uint = OpTypePointer Function %uint - %607 = OpConstantNull %uint + %604 = OpConstantNull %uint %uint_4096 = OpConstant %uint 4096 %coordsInBounds_vi2_vi2_ = OpFunction %bool None %45 %coord = OpFunctionParameter %_ptr_Function_v2int @@ -255,196 +252,196 @@ note: reading from module-scope private variable 'dimInner_1' may result in a no %x_87 = OpVariable %_ptr_Function_bool Function %54 %x_88_phi = OpVariable %_ptr_Function_bool Function %54 %57 = OpLoad %v2int %coord - %61 = OpSGreaterThanEqual %v2bool %57 %60 - %58 = OpAll %bool %61 + %60 = OpSGreaterThanEqual %v2bool %57 %59 + %58 = OpAll %bool %60 OpStore %x_88_phi %58 - OpSelectionMerge %63 None - OpBranchConditional %58 %64 %63 - %64 = OpLabel - %66 = OpLoad %v2int %coord - %68 = OpLoad %v2int %shape - %70 = OpSLessThan %v2bool %66 %68 - %69 = OpAll %bool %70 - OpStore %x_87 %69 - %71 = OpLoad %bool %x_87 - OpStore %x_88_phi %71 - OpBranch %63 + OpSelectionMerge %62 None + OpBranchConditional %58 %63 %62 %63 = OpLabel - %72 = OpLoad %bool %x_88_phi - OpReturnValue %72 + %65 = OpLoad %v2int %coord + %67 = OpLoad %v2int %shape + %69 = OpSLessThan %v2bool %65 %67 + %68 = OpAll %bool %69 + OpStore %x_87 %68 + %70 = OpLoad %bool %x_87 + OpStore %x_88_phi %70 + OpBranch %62 + %62 = OpLabel + %71 = OpLoad %bool %x_88_phi + OpReturnValue %71 OpFunctionEnd -%mm_readA_i1_i1_ = OpFunction %float None %73 +%mm_readA_i1_i1_ = OpFunction %float None %72 %row = OpFunctionParameter %_ptr_Function_int %col = OpFunctionParameter %_ptr_Function_int - %78 = OpLabel + %77 = OpLabel %batchASize = OpVariable %_ptr_Function_int Function %11 - %param_10 = OpVariable %_ptr_Function_v2int Function %81 - %param_11 = OpVariable %_ptr_Function_v2int Function %81 - %x_430 = OpVariable %_ptr_Function_float Function %85 - %87 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_1 %uint_1 - %88 = OpLoad %int %87 - %90 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_1 %uint_2 - %91 = OpLoad %int %90 - %92 = OpIMul %int %88 %91 - OpStore %batchASize %92 - %94 = OpLoad %int %row - %96 = OpLoad %int %col - %97 = OpLoad %int %dimAOuter_1 - %98 = OpLoad %int %dimInner_1 - %99 = OpCompositeConstruct %v2int %94 %96 - OpStore %param_10 %99 - %100 = OpCompositeConstruct %v2int %97 %98 - OpStore %param_11 %100 - %101 = OpFunctionCall %bool %coordsInBounds_vi2_vi2_ %param_10 %param_11 - OpSelectionMerge %104 None - OpBranchConditional %101 %105 %106 - %105 = OpLabel - %107 = OpLoad %int %batch - %108 = OpLoad %int %batchASize - %110 = OpLoad %int %row - %111 = OpLoad %int %dimInner_1 - %113 = OpLoad %int %col - %115 = OpIMul %int %107 %108 - %116 = OpIMul %int %110 %111 - %117 = OpIAdd %int %115 %116 - %118 = OpIAdd %int %117 %113 - %120 = OpAccessChain %_ptr_StorageBuffer_float %x_165 %uint_0 %118 - %121 = OpLoad %float %120 - OpStore %x_430 %121 - OpBranch %104 - %106 = OpLabel - OpStore %x_430 %float_0 - OpBranch %104 + %param_10 = OpVariable %_ptr_Function_v2int Function %59 + %param_11 = OpVariable %_ptr_Function_v2int Function %59 + %x_430 = OpVariable %_ptr_Function_float Function %83 + %85 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_1 %uint_1 + %86 = OpLoad %int %85 + %88 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_1 %uint_2 + %89 = OpLoad %int %88 + %90 = OpIMul %int %86 %89 + OpStore %batchASize %90 + %92 = OpLoad %int %row + %94 = OpLoad %int %col + %95 = OpLoad %int %dimAOuter_1 + %96 = OpLoad %int %dimInner_1 + %97 = OpCompositeConstruct %v2int %92 %94 + OpStore %param_10 %97 + %98 = OpCompositeConstruct %v2int %95 %96 + OpStore %param_11 %98 + %99 = OpFunctionCall %bool %coordsInBounds_vi2_vi2_ %param_10 %param_11 + OpSelectionMerge %102 None + OpBranchConditional %99 %103 %104 + %103 = OpLabel + %105 = OpLoad %int %batch + %106 = OpLoad %int %batchASize + %108 = OpLoad %int %row + %109 = OpLoad %int %dimInner_1 + %111 = OpLoad %int %col + %113 = OpIMul %int %105 %106 + %114 = OpIMul %int %108 %109 + %115 = OpIAdd %int %113 %114 + %116 = OpIAdd %int %115 %111 + %118 = OpAccessChain %_ptr_StorageBuffer_float %x_165 %uint_0 %116 + %119 = OpLoad %float %118 + OpStore %x_430 %119 + OpBranch %102 %104 = OpLabel - %123 = OpLoad %float %x_430 - OpReturnValue %123 + OpStore %x_430 %83 + OpBranch %102 + %102 = OpLabel + %120 = OpLoad %float %x_430 + OpReturnValue %120 OpFunctionEnd -%mm_readB_i1_i1_ = OpFunction %float None %73 +%mm_readB_i1_i1_ = OpFunction %float None %72 %row_1 = OpFunctionParameter %_ptr_Function_int %col_1 = OpFunctionParameter %_ptr_Function_int - %127 = OpLabel + %124 = OpLabel %batchBSize = OpVariable %_ptr_Function_int Function %11 - %param_12 = OpVariable %_ptr_Function_v2int Function %81 - %param_13 = OpVariable %_ptr_Function_v2int Function %81 - %x_468 = OpVariable %_ptr_Function_float Function %85 - %132 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_2 %uint_1 - %133 = OpLoad %int %132 - %134 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_2 %uint_2 - %135 = OpLoad %int %134 - %136 = OpIMul %int %133 %135 - OpStore %batchBSize %136 - %138 = OpLoad %int %row_1 - %140 = OpLoad %int %col_1 - %141 = OpLoad %int %dimInner_1 - %142 = OpLoad %int %dimBOuter_1 - %143 = OpCompositeConstruct %v2int %138 %140 - OpStore %param_12 %143 - %144 = OpCompositeConstruct %v2int %141 %142 - OpStore %param_13 %144 - %145 = OpFunctionCall %bool %coordsInBounds_vi2_vi2_ %param_12 %param_13 - OpSelectionMerge %148 None - OpBranchConditional %145 %149 %150 - %149 = OpLabel - %151 = OpLoad %int %batch - %152 = OpLoad %int %batchBSize - %154 = OpLoad %int %row_1 - %155 = OpLoad %int %dimBOuter_1 - %157 = OpLoad %int %col_1 - %158 = OpIMul %int %151 %152 - %159 = OpIMul %int %154 %155 - %160 = OpIAdd %int %158 %159 - %161 = OpIAdd %int %160 %157 - %162 = OpAccessChain %_ptr_StorageBuffer_float %x_185 %uint_0 %161 - %163 = OpLoad %float %162 - OpStore %x_468 %163 - OpBranch %148 - %150 = OpLabel - OpStore %x_468 %float_0 - OpBranch %148 - %148 = OpLabel - %164 = OpLoad %float %x_468 - OpReturnValue %164 + %param_12 = OpVariable %_ptr_Function_v2int Function %59 + %param_13 = OpVariable %_ptr_Function_v2int Function %59 + %x_468 = OpVariable %_ptr_Function_float Function %83 + %129 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_2 %uint_1 + %130 = OpLoad %int %129 + %131 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_2 %uint_2 + %132 = OpLoad %int %131 + %133 = OpIMul %int %130 %132 + OpStore %batchBSize %133 + %135 = OpLoad %int %row_1 + %137 = OpLoad %int %col_1 + %138 = OpLoad %int %dimInner_1 + %139 = OpLoad %int %dimBOuter_1 + %140 = OpCompositeConstruct %v2int %135 %137 + OpStore %param_12 %140 + %141 = OpCompositeConstruct %v2int %138 %139 + OpStore %param_13 %141 + %142 = OpFunctionCall %bool %coordsInBounds_vi2_vi2_ %param_12 %param_13 + OpSelectionMerge %145 None + OpBranchConditional %142 %146 %147 + %146 = OpLabel + %148 = OpLoad %int %batch + %149 = OpLoad %int %batchBSize + %151 = OpLoad %int %row_1 + %152 = OpLoad %int %dimBOuter_1 + %154 = OpLoad %int %col_1 + %155 = OpIMul %int %148 %149 + %156 = OpIMul %int %151 %152 + %157 = OpIAdd %int %155 %156 + %158 = OpIAdd %int %157 %154 + %159 = OpAccessChain %_ptr_StorageBuffer_float %x_185 %uint_0 %158 + %160 = OpLoad %float %159 + OpStore %x_468 %160 + OpBranch %145 + %147 = OpLabel + OpStore %x_468 %83 + OpBranch %145 + %145 = OpLabel + %161 = OpLoad %float %x_468 + OpReturnValue %161 OpFunctionEnd -%getOutputFlatIndex_vi3_ = OpFunction %int None %165 +%getOutputFlatIndex_vi3_ = OpFunction %int None %162 %coords = OpFunctionParameter %_ptr_Function_v3int - %169 = OpLabel - %171 = OpLoad %v3int %coords - %173 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_4 %uint_0 - %174 = OpLoad %int %173 - %175 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_4 %uint_1 - %176 = OpLoad %int %175 - %179 = OpConvertSToF %v3float %171 - %183 = OpCompositeConstruct %v3int %174 %176 %int_1 - %181 = OpConvertSToF %v3float %183 - %178 = OpDot %float %179 %181 - %177 = OpConvertFToS %int %178 - OpReturnValue %177 + %166 = OpLabel + %168 = OpLoad %v3int %coords + %170 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_4 %uint_0 + %171 = OpLoad %int %170 + %172 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_4 %uint_1 + %173 = OpLoad %int %172 + %176 = OpConvertSToF %v3float %168 + %180 = OpCompositeConstruct %v3int %171 %173 %int_1 + %178 = OpConvertSToF %v3float %180 + %175 = OpDot %float %176 %178 + %174 = OpConvertFToS %int %175 + OpReturnValue %174 OpFunctionEnd -%setOutput_i1_f1_ = OpFunction %void None %184 +%setOutput_i1_f1_ = OpFunction %void None %181 %flatIndex = OpFunctionParameter %_ptr_Function_int %value = OpFunctionParameter %_ptr_Function_float - %189 = OpLabel - %191 = OpLoad %int %flatIndex - %193 = OpLoad %float %value - %194 = OpAccessChain %_ptr_StorageBuffer_float %x_54 %uint_0 %191 - OpStore %194 %193 + %186 = OpLabel + %188 = OpLoad %int %flatIndex + %190 = OpLoad %float %value + %191 = OpAccessChain %_ptr_StorageBuffer_float %x_54 %uint_0 %188 + OpStore %191 %190 OpReturn OpFunctionEnd -%setOutput_i1_i1_i1_f1_ = OpFunction %void None %195 +%setOutput_i1_i1_i1_f1_ = OpFunction %void None %192 %d0 = OpFunctionParameter %_ptr_Function_int %d1 = OpFunctionParameter %_ptr_Function_int %d2 = OpFunctionParameter %_ptr_Function_int %value_1 = OpFunctionParameter %_ptr_Function_float - %201 = OpLabel + %198 = OpLabel %flatIndex_1 = OpVariable %_ptr_Function_int Function %11 - %param = OpVariable %_ptr_Function_v3int Function %204 + %param = OpVariable %_ptr_Function_v3int Function %201 %param_1 = OpVariable %_ptr_Function_int Function %11 - %param_2 = OpVariable %_ptr_Function_float Function %85 - %208 = OpLoad %int %d0 - %210 = OpLoad %int %d1 - %212 = OpLoad %int %d2 - %213 = OpCompositeConstruct %v3int %208 %210 %212 - OpStore %param %213 - %214 = OpFunctionCall %int %getOutputFlatIndex_vi3_ %param - OpStore %flatIndex_1 %214 - %216 = OpLoad %int %flatIndex_1 - OpStore %param_1 %216 - %218 = OpLoad %float %value_1 - OpStore %param_2 %218 - %219 = OpFunctionCall %void %setOutput_i1_f1_ %param_1 %param_2 + %param_2 = OpVariable %_ptr_Function_float Function %83 + %205 = OpLoad %int %d0 + %207 = OpLoad %int %d1 + %209 = OpLoad %int %d2 + %210 = OpCompositeConstruct %v3int %205 %207 %209 + OpStore %param %210 + %211 = OpFunctionCall %int %getOutputFlatIndex_vi3_ %param + OpStore %flatIndex_1 %211 + %213 = OpLoad %int %flatIndex_1 + OpStore %param_1 %213 + %215 = OpLoad %float %value_1 + OpStore %param_2 %215 + %216 = OpFunctionCall %void %setOutput_i1_f1_ %param_1 %param_2 OpReturn OpFunctionEnd -%mm_write_i1_i1_f1_ = OpFunction %void None %222 +%mm_write_i1_i1_f1_ = OpFunction %void None %219 %row_2 = OpFunctionParameter %_ptr_Function_int %col_2 = OpFunctionParameter %_ptr_Function_int %value_2 = OpFunctionParameter %_ptr_Function_float - %227 = OpLabel - %outCoord = OpVariable %_ptr_Function_v3int Function %204 + %224 = OpLabel + %outCoord = OpVariable %_ptr_Function_v3int Function %201 %param_14 = OpVariable %_ptr_Function_int Function %11 %param_15 = OpVariable %_ptr_Function_int Function %11 %param_16 = OpVariable %_ptr_Function_int Function %11 - %param_17 = OpVariable %_ptr_Function_float Function %85 - %233 = OpLoad %int %batch - %235 = OpLoad %int %row_2 - %237 = OpLoad %int %col_2 - %238 = OpCompositeConstruct %v3int %233 %235 %237 - OpStore %outCoord %238 - %239 = OpLoad %int %batch - OpStore %param_14 %239 - %241 = OpLoad %int %row_2 - OpStore %param_15 %241 - %243 = OpLoad %int %col_2 - OpStore %param_16 %243 - %245 = OpLoad %float %value_2 - OpStore %param_17 %245 - %246 = OpFunctionCall %void %setOutput_i1_i1_i1_f1_ %param_14 %param_15 %param_16 %param_17 + %param_17 = OpVariable %_ptr_Function_float Function %83 + %230 = OpLoad %int %batch + %232 = OpLoad %int %row_2 + %234 = OpLoad %int %col_2 + %235 = OpCompositeConstruct %v3int %230 %232 %234 + OpStore %outCoord %235 + %236 = OpLoad %int %batch + OpStore %param_14 %236 + %238 = OpLoad %int %row_2 + OpStore %param_15 %238 + %240 = OpLoad %int %col_2 + OpStore %param_16 %240 + %242 = OpLoad %float %value_2 + OpStore %param_17 %242 + %243 = OpFunctionCall %void %setOutput_i1_i1_i1_f1_ %param_14 %param_15 %param_16 %param_17 OpReturn OpFunctionEnd -%mm_matMul_i1_i1_i1_ = OpFunction %void None %251 +%mm_matMul_i1_i1_i1_ = OpFunction %void None %248 %dimAOuter = OpFunctionParameter %_ptr_Function_int %dimInner = OpFunctionParameter %_ptr_Function_int %dimBOuter = OpFunctionParameter %_ptr_Function_int - %256 = OpLabel + %253 = OpLabel %tileRow = OpVariable %_ptr_Function_int Function %11 %tileCol = OpVariable %_ptr_Function_int Function %11 %globalRow = OpVariable %_ptr_Function_int Function %11 @@ -452,7 +449,7 @@ note: reading from module-scope private variable 'dimInner_1' may result in a no %numTiles = OpVariable %_ptr_Function_int Function %11 %innerRow = OpVariable %_ptr_Function_int Function %11 %innerCol = OpVariable %_ptr_Function_int Function %11 - %acc = OpVariable %_ptr_Function__arr__arr_float_uint_1_uint_1 Function %267 + %acc = OpVariable %_ptr_Function__arr__arr_float_uint_1_uint_1 Function %264 %tileColA = OpVariable %_ptr_Function_int Function %11 %tileRowB = OpVariable %_ptr_Function_int Function %11 %t = OpVariable %_ptr_Function_int Function %11 @@ -470,532 +467,532 @@ note: reading from module-scope private variable 'dimInner_1' may result in a no %param_6 = OpVariable %_ptr_Function_int Function %11 %k = OpVariable %_ptr_Function_int Function %11 %inner = OpVariable %_ptr_Function_int Function %11 - %BCached = OpVariable %_ptr_Function__arr_float_uint_1 Function %287 + %BCached = OpVariable %_ptr_Function__arr_float_uint_1 Function %284 %innerRow_3 = OpVariable %_ptr_Function_int Function %11 - %ACached = OpVariable %_ptr_Function_float Function %85 + %ACached = OpVariable %_ptr_Function_float Function %83 %innerCol_3 = OpVariable %_ptr_Function_int Function %11 %innerRow_4 = OpVariable %_ptr_Function_int Function %11 %innerCol_4 = OpVariable %_ptr_Function_int Function %11 %param_7 = OpVariable %_ptr_Function_int Function %11 %param_8 = OpVariable %_ptr_Function_int Function %11 - %param_9 = OpVariable %_ptr_Function_float Function %85 + %param_9 = OpVariable %_ptr_Function_float Function %83 %x_393 = OpVariable %_ptr_Function_bool Function %54 %x_394_phi = OpVariable %_ptr_Function_bool Function %54 - %297 = OpAccessChain %_ptr_Private_uint %gl_LocalInvocationID %uint_1 - %298 = OpLoad %uint %297 - %299 = OpBitcast %int %298 - %300 = OpIMul %int %299 %int_1 - OpStore %tileRow %300 - %301 = OpAccessChain %_ptr_Private_uint %gl_LocalInvocationID %uint_0 - %302 = OpLoad %uint %301 - %303 = OpBitcast %int %302 - %304 = OpIMul %int %303 %int_1 - OpStore %tileCol %304 - %305 = OpAccessChain %_ptr_Private_uint %gl_GlobalInvocationID %uint_1 - %306 = OpLoad %uint %305 - %307 = OpBitcast %int %306 - %308 = OpIMul %int %307 %int_1 - OpStore %globalRow %308 - %309 = OpAccessChain %_ptr_Private_uint %gl_GlobalInvocationID %uint_0 - %310 = OpLoad %uint %309 - %311 = OpBitcast %int %310 - %312 = OpIMul %int %311 %int_1 - OpStore %globalCol %312 - %314 = OpLoad %int %dimInner - %315 = OpISub %int %314 %int_1 - %317 = OpSDiv %int %315 %int_64 - %318 = OpIAdd %int %317 %int_1 - OpStore %numTiles %318 - OpStore %innerRow %int_0 + %294 = OpAccessChain %_ptr_Private_uint %gl_LocalInvocationID %uint_1 + %295 = OpLoad %uint %294 + %296 = OpBitcast %int %295 + %297 = OpIMul %int %296 %int_1 + OpStore %tileRow %297 + %298 = OpAccessChain %_ptr_Private_uint %gl_LocalInvocationID %uint_0 + %299 = OpLoad %uint %298 + %300 = OpBitcast %int %299 + %301 = OpIMul %int %300 %int_1 + OpStore %tileCol %301 + %302 = OpAccessChain %_ptr_Private_uint %gl_GlobalInvocationID %uint_1 + %303 = OpLoad %uint %302 + %304 = OpBitcast %int %303 + %305 = OpIMul %int %304 %int_1 + OpStore %globalRow %305 + %306 = OpAccessChain %_ptr_Private_uint %gl_GlobalInvocationID %uint_0 + %307 = OpLoad %uint %306 + %308 = OpBitcast %int %307 + %309 = OpIMul %int %308 %int_1 + OpStore %globalCol %309 + %311 = OpLoad %int %dimInner + %312 = OpISub %int %311 %int_1 + %314 = OpSDiv %int %312 %int_64 + %315 = OpIAdd %int %314 %int_1 + OpStore %numTiles %315 + OpStore %innerRow %11 + OpBranch %316 + %316 = OpLabel + OpLoopMerge %317 %318 None OpBranch %319 %319 = OpLabel - OpLoopMerge %320 %321 None + %320 = OpLoad %int %innerRow + %321 = OpSLessThan %bool %320 %int_1 + OpSelectionMerge %322 None + OpBranchConditional %321 %323 %324 + %323 = OpLabel OpBranch %322 + %324 = OpLabel + OpBranch %317 %322 = OpLabel - %323 = OpLoad %int %innerRow - %324 = OpSLessThan %bool %323 %int_1 - OpSelectionMerge %325 None - OpBranchConditional %324 %326 %327 - %326 = OpLabel + OpStore %innerCol %11 OpBranch %325 - %327 = OpLabel - OpBranch %320 %325 = OpLabel - OpStore %innerCol %int_0 + OpLoopMerge %326 %327 None OpBranch %328 %328 = OpLabel - OpLoopMerge %329 %330 None + %329 = OpLoad %int %innerCol + %330 = OpSLessThan %bool %329 %int_1 + OpSelectionMerge %331 None + OpBranchConditional %330 %332 %333 + %332 = OpLabel OpBranch %331 + %333 = OpLabel + OpBranch %326 %331 = OpLabel - %332 = OpLoad %int %innerCol - %333 = OpSLessThan %bool %332 %int_1 - OpSelectionMerge %334 None - OpBranchConditional %333 %335 %336 - %335 = OpLabel - OpBranch %334 - %336 = OpLabel - OpBranch %329 - %334 = OpLabel - %337 = OpLoad %int %innerRow - %338 = OpLoad %int %innerCol - %339 = OpAccessChain %_ptr_Function_float %acc %337 %338 - OpStore %339 %float_0 - OpBranch %330 - %330 = OpLabel - %340 = OpLoad %int %innerCol - %341 = OpIAdd %int %340 %int_1 - OpStore %innerCol %341 - OpBranch %328 - %329 = OpLabel - OpBranch %321 - %321 = OpLabel - %342 = OpLoad %int %innerRow - %343 = OpIAdd %int %342 %int_1 - OpStore %innerRow %343 - OpBranch %319 - %320 = OpLabel - %344 = OpAccessChain %_ptr_Private_uint %gl_LocalInvocationID %uint_0 - %345 = OpLoad %uint %344 - %346 = OpBitcast %int %345 - %347 = OpIMul %int %346 %int_64 - OpStore %tileColA %347 - %348 = OpAccessChain %_ptr_Private_uint %gl_LocalInvocationID %uint_1 - %349 = OpLoad %uint %348 - %350 = OpBitcast %int %349 - %351 = OpIMul %int %350 %int_1 - OpStore %tileRowB %351 - OpStore %t %int_0 + %334 = OpLoad %int %innerRow + %335 = OpLoad %int %innerCol + %336 = OpAccessChain %_ptr_Function_float %acc %334 %335 + OpStore %336 %83 + OpBranch %327 + %327 = OpLabel + %337 = OpLoad %int %innerCol + %338 = OpIAdd %int %337 %int_1 + OpStore %innerCol %338 + OpBranch %325 + %326 = OpLabel + OpBranch %318 + %318 = OpLabel + %339 = OpLoad %int %innerRow + %340 = OpIAdd %int %339 %int_1 + OpStore %innerRow %340 + OpBranch %316 + %317 = OpLabel + %341 = OpAccessChain %_ptr_Private_uint %gl_LocalInvocationID %uint_0 + %342 = OpLoad %uint %341 + %343 = OpBitcast %int %342 + %344 = OpIMul %int %343 %int_64 + OpStore %tileColA %344 + %345 = OpAccessChain %_ptr_Private_uint %gl_LocalInvocationID %uint_1 + %346 = OpLoad %uint %345 + %347 = OpBitcast %int %346 + %348 = OpIMul %int %347 %int_1 + OpStore %tileRowB %348 + OpStore %t %11 + OpBranch %349 + %349 = OpLabel + OpLoopMerge %350 %351 None OpBranch %352 %352 = OpLabel - OpLoopMerge %353 %354 None - OpBranch %355 - %355 = OpLabel - %356 = OpLoad %int %t - %357 = OpLoad %int %numTiles - %358 = OpSLessThan %bool %356 %357 - OpSelectionMerge %359 None - OpBranchConditional %358 %360 %361 - %360 = OpLabel + %353 = OpLoad %int %t + %354 = OpLoad %int %numTiles + %355 = OpSLessThan %bool %353 %354 + OpSelectionMerge %356 None + OpBranchConditional %355 %357 %358 + %357 = OpLabel + OpBranch %356 + %358 = OpLabel + OpBranch %350 + %356 = OpLabel + OpStore %innerRow_1 %11 OpBranch %359 - %361 = OpLabel - OpBranch %353 %359 = OpLabel - OpStore %innerRow_1 %int_0 + OpLoopMerge %360 %361 None OpBranch %362 %362 = OpLabel - OpLoopMerge %363 %364 None + %363 = OpLoad %int %innerRow_1 + %364 = OpSLessThan %bool %363 %int_1 + OpSelectionMerge %365 None + OpBranchConditional %364 %366 %367 + %366 = OpLabel OpBranch %365 + %367 = OpLabel + OpBranch %360 %365 = OpLabel - %366 = OpLoad %int %innerRow_1 - %367 = OpSLessThan %bool %366 %int_1 - OpSelectionMerge %368 None - OpBranchConditional %367 %369 %370 - %369 = OpLabel + OpStore %innerCol_1 %11 OpBranch %368 - %370 = OpLabel - OpBranch %363 %368 = OpLabel - OpStore %innerCol_1 %int_0 + OpLoopMerge %369 %370 None OpBranch %371 %371 = OpLabel - OpLoopMerge %372 %373 None + %372 = OpLoad %int %innerCol_1 + %373 = OpSLessThan %bool %372 %int_64 + OpSelectionMerge %374 None + OpBranchConditional %373 %375 %376 + %375 = OpLabel OpBranch %374 + %376 = OpLabel + OpBranch %369 %374 = OpLabel - %375 = OpLoad %int %innerCol_1 - %376 = OpSLessThan %bool %375 %int_64 - OpSelectionMerge %377 None - OpBranchConditional %376 %378 %379 - %378 = OpLabel - OpBranch %377 - %379 = OpLabel - OpBranch %372 - %377 = OpLabel - %380 = OpLoad %int %tileRow - %381 = OpLoad %int %innerRow_1 + %377 = OpLoad %int %tileRow + %378 = OpLoad %int %innerRow_1 + %379 = OpIAdd %int %377 %378 + OpStore %inputRow %379 + %380 = OpLoad %int %tileColA + %381 = OpLoad %int %innerCol_1 %382 = OpIAdd %int %380 %381 - OpStore %inputRow %382 - %383 = OpLoad %int %tileColA - %384 = OpLoad %int %innerCol_1 - %385 = OpIAdd %int %383 %384 - OpStore %inputCol %385 - %386 = OpLoad %int %inputRow - %387 = OpLoad %int %inputCol - %388 = OpLoad %int %globalRow - %389 = OpLoad %int %innerRow_1 - %390 = OpLoad %int %t - %391 = OpLoad %int %inputCol - %392 = OpIAdd %int %388 %389 - OpStore %param_3 %392 - %393 = OpIMul %int %390 %int_64 - %394 = OpIAdd %int %393 %391 - OpStore %param_4 %394 - %395 = OpFunctionCall %float %mm_readA_i1_i1_ %param_3 %param_4 - %399 = OpAccessChain %_ptr_Workgroup_float %mm_Asub %386 %387 - OpStore %399 %395 - OpBranch %373 - %373 = OpLabel - %400 = OpLoad %int %innerCol_1 - %401 = OpIAdd %int %400 %int_1 - OpStore %innerCol_1 %401 - OpBranch %371 - %372 = OpLabel - OpBranch %364 - %364 = OpLabel - %402 = OpLoad %int %innerRow_1 - %403 = OpIAdd %int %402 %int_1 - OpStore %innerRow_1 %403 - OpBranch %362 - %363 = OpLabel - OpStore %innerRow_2 %int_0 + OpStore %inputCol %382 + %383 = OpLoad %int %inputRow + %384 = OpLoad %int %inputCol + %385 = OpLoad %int %globalRow + %386 = OpLoad %int %innerRow_1 + %387 = OpLoad %int %t + %388 = OpLoad %int %inputCol + %389 = OpIAdd %int %385 %386 + OpStore %param_3 %389 + %390 = OpIMul %int %387 %int_64 + %391 = OpIAdd %int %390 %388 + OpStore %param_4 %391 + %392 = OpFunctionCall %float %mm_readA_i1_i1_ %param_3 %param_4 + %396 = OpAccessChain %_ptr_Workgroup_float %mm_Asub %383 %384 + OpStore %396 %392 + OpBranch %370 + %370 = OpLabel + %397 = OpLoad %int %innerCol_1 + %398 = OpIAdd %int %397 %int_1 + OpStore %innerCol_1 %398 + OpBranch %368 + %369 = OpLabel + OpBranch %361 + %361 = OpLabel + %399 = OpLoad %int %innerRow_1 + %400 = OpIAdd %int %399 %int_1 + OpStore %innerRow_1 %400 + OpBranch %359 + %360 = OpLabel + OpStore %innerRow_2 %11 + OpBranch %401 + %401 = OpLabel + OpLoopMerge %402 %403 None OpBranch %404 %404 = OpLabel - OpLoopMerge %405 %406 None + %405 = OpLoad %int %innerRow_2 + %406 = OpSLessThan %bool %405 %int_1 + OpSelectionMerge %407 None + OpBranchConditional %406 %408 %409 + %408 = OpLabel OpBranch %407 + %409 = OpLabel + OpBranch %402 %407 = OpLabel - %408 = OpLoad %int %innerRow_2 - %409 = OpSLessThan %bool %408 %int_1 - OpSelectionMerge %410 None - OpBranchConditional %409 %411 %412 - %411 = OpLabel + OpStore %innerCol_2 %11 OpBranch %410 - %412 = OpLabel - OpBranch %405 %410 = OpLabel - OpStore %innerCol_2 %int_0 + OpLoopMerge %411 %412 None OpBranch %413 %413 = OpLabel - OpLoopMerge %414 %415 None + %414 = OpLoad %int %innerCol_2 + %415 = OpSLessThan %bool %414 %int_1 + OpSelectionMerge %416 None + OpBranchConditional %415 %417 %418 + %417 = OpLabel OpBranch %416 + %418 = OpLabel + OpBranch %411 %416 = OpLabel - %417 = OpLoad %int %innerCol_2 - %418 = OpSLessThan %bool %417 %int_1 - OpSelectionMerge %419 None - OpBranchConditional %418 %420 %421 - %420 = OpLabel - OpBranch %419 - %421 = OpLabel - OpBranch %414 - %419 = OpLabel - %422 = OpLoad %int %tileRowB - %423 = OpLoad %int %innerRow_2 + %419 = OpLoad %int %tileRowB + %420 = OpLoad %int %innerRow_2 + %421 = OpIAdd %int %419 %420 + OpStore %inputRow_1 %421 + %422 = OpLoad %int %tileCol + %423 = OpLoad %int %innerCol_2 %424 = OpIAdd %int %422 %423 - OpStore %inputRow_1 %424 - %425 = OpLoad %int %tileCol - %426 = OpLoad %int %innerCol_2 - %427 = OpIAdd %int %425 %426 - OpStore %inputCol_1 %427 + OpStore %inputCol_1 %424 + %425 = OpLoad %int %inputRow_1 + %426 = OpLoad %int %inputCol_1 + %427 = OpLoad %int %t %428 = OpLoad %int %inputRow_1 - %429 = OpLoad %int %inputCol_1 - %430 = OpLoad %int %t - %431 = OpLoad %int %inputRow_1 - %432 = OpLoad %int %globalCol - %433 = OpLoad %int %innerCol_2 - %434 = OpIMul %int %430 %int_64 - %435 = OpIAdd %int %434 %431 - OpStore %param_5 %435 - %436 = OpIAdd %int %432 %433 - OpStore %param_6 %436 - %437 = OpFunctionCall %float %mm_readB_i1_i1_ %param_5 %param_6 - %440 = OpAccessChain %_ptr_Workgroup_float %mm_Bsub %428 %429 - OpStore %440 %437 - OpBranch %415 - %415 = OpLabel - %441 = OpLoad %int %innerCol_2 - %442 = OpIAdd %int %441 %int_1 - OpStore %innerCol_2 %442 - OpBranch %413 - %414 = OpLabel - OpBranch %406 - %406 = OpLabel - %443 = OpLoad %int %innerRow_2 - %444 = OpIAdd %int %443 %int_1 - OpStore %innerRow_2 %444 - OpBranch %404 - %405 = OpLabel + %429 = OpLoad %int %globalCol + %430 = OpLoad %int %innerCol_2 + %431 = OpIMul %int %427 %int_64 + %432 = OpIAdd %int %431 %428 + OpStore %param_5 %432 + %433 = OpIAdd %int %429 %430 + OpStore %param_6 %433 + %434 = OpFunctionCall %float %mm_readB_i1_i1_ %param_5 %param_6 + %437 = OpAccessChain %_ptr_Workgroup_float %mm_Bsub %425 %426 + OpStore %437 %434 + OpBranch %412 + %412 = OpLabel + %438 = OpLoad %int %innerCol_2 + %439 = OpIAdd %int %438 %int_1 + OpStore %innerCol_2 %439 + OpBranch %410 + %411 = OpLabel + OpBranch %403 + %403 = OpLabel + %440 = OpLoad %int %innerRow_2 + %441 = OpIAdd %int %440 %int_1 + OpStore %innerRow_2 %441 + OpBranch %401 + %402 = OpLabel OpControlBarrier %uint_2 %uint_2 %uint_264 - OpStore %k %int_0 + OpStore %k %11 + OpBranch %444 + %444 = OpLabel + OpLoopMerge %445 %446 None OpBranch %447 %447 = OpLabel - OpLoopMerge %448 %449 None + %448 = OpLoad %int %k + %449 = OpSLessThan %bool %448 %int_64 + OpSelectionMerge %450 None + OpBranchConditional %449 %451 %452 + %451 = OpLabel OpBranch %450 + %452 = OpLabel + OpBranch %445 %450 = OpLabel - %451 = OpLoad %int %k - %452 = OpSLessThan %bool %451 %int_64 - OpSelectionMerge %453 None - OpBranchConditional %452 %454 %455 - %454 = OpLabel + OpStore %inner %11 OpBranch %453 - %455 = OpLabel - OpBranch %448 %453 = OpLabel - OpStore %inner %int_0 + OpLoopMerge %454 %455 None OpBranch %456 %456 = OpLabel - OpLoopMerge %457 %458 None + %457 = OpLoad %int %inner + %458 = OpSLessThan %bool %457 %int_1 + OpSelectionMerge %459 None + OpBranchConditional %458 %460 %461 + %460 = OpLabel OpBranch %459 + %461 = OpLabel + OpBranch %454 %459 = OpLabel - %460 = OpLoad %int %inner - %461 = OpSLessThan %bool %460 %int_1 - OpSelectionMerge %462 None - OpBranchConditional %461 %463 %464 - %463 = OpLabel - OpBranch %462 - %464 = OpLabel - OpBranch %457 - %462 = OpLabel + %462 = OpLoad %int %inner + %463 = OpLoad %int %k + %464 = OpLoad %int %tileCol %465 = OpLoad %int %inner - %466 = OpLoad %int %k - %467 = OpLoad %int %tileCol - %468 = OpLoad %int %inner - %469 = OpIAdd %int %467 %468 - %470 = OpAccessChain %_ptr_Workgroup_float %mm_Bsub %466 %469 - %471 = OpLoad %float %470 - %472 = OpAccessChain %_ptr_Function_float %BCached %465 - OpStore %472 %471 - OpBranch %458 - %458 = OpLabel - %473 = OpLoad %int %inner - %474 = OpIAdd %int %473 %int_1 - OpStore %inner %474 - OpBranch %456 - %457 = OpLabel - OpStore %innerRow_3 %int_0 + %466 = OpIAdd %int %464 %465 + %467 = OpAccessChain %_ptr_Workgroup_float %mm_Bsub %463 %466 + %468 = OpLoad %float %467 + %469 = OpAccessChain %_ptr_Function_float %BCached %462 + OpStore %469 %468 + OpBranch %455 + %455 = OpLabel + %470 = OpLoad %int %inner + %471 = OpIAdd %int %470 %int_1 + OpStore %inner %471 + OpBranch %453 + %454 = OpLabel + OpStore %innerRow_3 %11 + OpBranch %472 + %472 = OpLabel + OpLoopMerge %473 %474 None OpBranch %475 %475 = OpLabel - OpLoopMerge %476 %477 None + %476 = OpLoad %int %innerRow_3 + %477 = OpSLessThan %bool %476 %int_1 + OpSelectionMerge %478 None + OpBranchConditional %477 %479 %480 + %479 = OpLabel OpBranch %478 + %480 = OpLabel + OpBranch %473 %478 = OpLabel - %479 = OpLoad %int %innerRow_3 - %480 = OpSLessThan %bool %479 %int_1 - OpSelectionMerge %481 None - OpBranchConditional %480 %482 %483 - %482 = OpLabel - OpBranch %481 - %483 = OpLabel - OpBranch %476 - %481 = OpLabel - %484 = OpLoad %int %tileRow - %485 = OpLoad %int %innerRow_3 - %486 = OpLoad %int %k - %487 = OpIAdd %int %484 %485 - %488 = OpAccessChain %_ptr_Workgroup_float %mm_Asub %487 %486 - %489 = OpLoad %float %488 - OpStore %ACached %489 - OpStore %innerCol_3 %int_0 + %481 = OpLoad %int %tileRow + %482 = OpLoad %int %innerRow_3 + %483 = OpLoad %int %k + %484 = OpIAdd %int %481 %482 + %485 = OpAccessChain %_ptr_Workgroup_float %mm_Asub %484 %483 + %486 = OpLoad %float %485 + OpStore %ACached %486 + OpStore %innerCol_3 %11 + OpBranch %487 + %487 = OpLabel + OpLoopMerge %488 %489 None OpBranch %490 %490 = OpLabel - OpLoopMerge %491 %492 None + %491 = OpLoad %int %innerCol_3 + %492 = OpSLessThan %bool %491 %int_1 + OpSelectionMerge %493 None + OpBranchConditional %492 %494 %495 + %494 = OpLabel OpBranch %493 + %495 = OpLabel + OpBranch %488 %493 = OpLabel - %494 = OpLoad %int %innerCol_3 - %495 = OpSLessThan %bool %494 %int_1 - OpSelectionMerge %496 None - OpBranchConditional %495 %497 %498 - %497 = OpLabel - OpBranch %496 - %498 = OpLabel - OpBranch %491 - %496 = OpLabel - %499 = OpLoad %int %innerRow_3 - %500 = OpLoad %int %innerCol_3 - %501 = OpLoad %float %ACached - %502 = OpLoad %int %innerCol_3 - %503 = OpAccessChain %_ptr_Function_float %BCached %502 - %504 = OpLoad %float %503 - %505 = OpAccessChain %_ptr_Function_float %acc %499 %500 - %506 = OpLoad %float %505 - %507 = OpAccessChain %_ptr_Function_float %acc %499 %500 - %508 = OpFMul %float %501 %504 - %509 = OpFAdd %float %506 %508 - OpStore %507 %509 - OpBranch %492 - %492 = OpLabel - %510 = OpLoad %int %innerCol_3 - %511 = OpIAdd %int %510 %int_1 - OpStore %innerCol_3 %511 - OpBranch %490 - %491 = OpLabel - OpBranch %477 - %477 = OpLabel - %512 = OpLoad %int %innerRow_3 - %513 = OpIAdd %int %512 %int_1 - OpStore %innerRow_3 %513 - OpBranch %475 - %476 = OpLabel - OpBranch %449 - %449 = OpLabel - %514 = OpLoad %int %k - %515 = OpIAdd %int %514 %int_1 - OpStore %k %515 - OpBranch %447 - %448 = OpLabel + %496 = OpLoad %int %innerRow_3 + %497 = OpLoad %int %innerCol_3 + %498 = OpLoad %float %ACached + %499 = OpLoad %int %innerCol_3 + %500 = OpAccessChain %_ptr_Function_float %BCached %499 + %501 = OpLoad %float %500 + %502 = OpAccessChain %_ptr_Function_float %acc %496 %497 + %503 = OpLoad %float %502 + %504 = OpAccessChain %_ptr_Function_float %acc %496 %497 + %505 = OpFMul %float %498 %501 + %506 = OpFAdd %float %503 %505 + OpStore %504 %506 + OpBranch %489 + %489 = OpLabel + %507 = OpLoad %int %innerCol_3 + %508 = OpIAdd %int %507 %int_1 + OpStore %innerCol_3 %508 + OpBranch %487 + %488 = OpLabel + OpBranch %474 + %474 = OpLabel + %509 = OpLoad %int %innerRow_3 + %510 = OpIAdd %int %509 %int_1 + OpStore %innerRow_3 %510 + OpBranch %472 + %473 = OpLabel + OpBranch %446 + %446 = OpLabel + %511 = OpLoad %int %k + %512 = OpIAdd %int %511 %int_1 + OpStore %k %512 + OpBranch %444 + %445 = OpLabel OpControlBarrier %uint_2 %uint_2 %uint_264 - OpBranch %354 - %354 = OpLabel - %517 = OpLoad %int %t - %518 = OpIAdd %int %517 %int_1 - OpStore %t %518 - OpBranch %352 - %353 = OpLabel - OpStore %innerRow_4 %int_0 + OpBranch %351 + %351 = OpLabel + %514 = OpLoad %int %t + %515 = OpIAdd %int %514 %int_1 + OpStore %t %515 + OpBranch %349 + %350 = OpLabel + OpStore %innerRow_4 %11 + OpBranch %516 + %516 = OpLabel + OpLoopMerge %517 %518 None OpBranch %519 %519 = OpLabel - OpLoopMerge %520 %521 None + %520 = OpLoad %int %innerRow_4 + %521 = OpSLessThan %bool %520 %int_1 + OpSelectionMerge %522 None + OpBranchConditional %521 %523 %524 + %523 = OpLabel OpBranch %522 + %524 = OpLabel + OpBranch %517 %522 = OpLabel - %523 = OpLoad %int %innerRow_4 - %524 = OpSLessThan %bool %523 %int_1 - OpSelectionMerge %525 None - OpBranchConditional %524 %526 %527 - %526 = OpLabel + OpStore %innerCol_4 %11 OpBranch %525 - %527 = OpLabel - OpBranch %520 %525 = OpLabel - OpStore %innerCol_4 %int_0 + OpLoopMerge %526 %527 None OpBranch %528 %528 = OpLabel - OpLoopMerge %529 %530 None - OpBranch %531 - %531 = OpLabel - %534 = OpLoad %int %innerCol_4 - %535 = OpSLessThan %bool %534 %int_1 - OpSelectionMerge %536 None - OpBranchConditional %535 %537 %538 - %537 = OpLabel - OpBranch %536 - %538 = OpLabel - OpBranch %529 - %536 = OpLabel - %539 = OpLoad %int %globalCol - %540 = OpLoad %int %innerCol_4 - %542 = OpLoad %int %dimBOuter - %543 = OpIAdd %int %539 %540 - %544 = OpSLessThan %bool %543 %542 - OpStore %x_394_phi %544 - OpSelectionMerge %545 None - OpBranchConditional %544 %546 %545 - %546 = OpLabel - %547 = OpLoad %int %globalRow - %548 = OpLoad %int %innerRow_4 - %550 = OpLoad %int %dimAOuter - %551 = OpIAdd %int %547 %548 - %552 = OpSLessThan %bool %551 %550 - OpStore %x_393 %552 - %553 = OpLoad %bool %x_393 - OpStore %x_394_phi %553 - OpBranch %545 - %545 = OpLabel - %554 = OpLoad %bool %x_394_phi - OpSelectionMerge %555 None - OpBranchConditional %554 %556 %555 - %556 = OpLabel - %557 = OpLoad %int %globalRow + %531 = OpLoad %int %innerCol_4 + %532 = OpSLessThan %bool %531 %int_1 + OpSelectionMerge %533 None + OpBranchConditional %532 %534 %535 + %534 = OpLabel + OpBranch %533 + %535 = OpLabel + OpBranch %526 + %533 = OpLabel + %536 = OpLoad %int %globalCol + %537 = OpLoad %int %innerCol_4 + %539 = OpLoad %int %dimBOuter + %540 = OpIAdd %int %536 %537 + %541 = OpSLessThan %bool %540 %539 + OpStore %x_394_phi %541 + OpSelectionMerge %542 None + OpBranchConditional %541 %543 %542 + %543 = OpLabel + %544 = OpLoad %int %globalRow + %545 = OpLoad %int %innerRow_4 + %547 = OpLoad %int %dimAOuter + %548 = OpIAdd %int %544 %545 + %549 = OpSLessThan %bool %548 %547 + OpStore %x_393 %549 + %550 = OpLoad %bool %x_393 + OpStore %x_394_phi %550 + OpBranch %542 + %542 = OpLabel + %551 = OpLoad %bool %x_394_phi + OpSelectionMerge %552 None + OpBranchConditional %551 %553 %552 + %553 = OpLabel + %554 = OpLoad %int %globalRow + %555 = OpLoad %int %innerRow_4 + %556 = OpLoad %int %globalCol + %557 = OpLoad %int %innerCol_4 %558 = OpLoad %int %innerRow_4 - %559 = OpLoad %int %globalCol - %560 = OpLoad %int %innerCol_4 - %561 = OpLoad %int %innerRow_4 - %562 = OpLoad %int %innerCol_4 - %563 = OpIAdd %int %557 %558 - OpStore %param_7 %563 - %564 = OpIAdd %int %559 %560 - OpStore %param_8 %564 - %565 = OpAccessChain %_ptr_Function_float %acc %561 %562 - %566 = OpLoad %float %565 - OpStore %param_9 %566 - %567 = OpFunctionCall %void %mm_write_i1_i1_f1_ %param_7 %param_8 %param_9 - OpBranch %555 - %555 = OpLabel - OpBranch %530 - %530 = OpLabel - %571 = OpLoad %int %innerCol_4 - %572 = OpIAdd %int %571 %int_1 - OpStore %innerCol_4 %572 - OpBranch %528 - %529 = OpLabel - OpBranch %521 - %521 = OpLabel - %573 = OpLoad %int %innerRow_4 - %574 = OpIAdd %int %573 %int_1 - OpStore %innerRow_4 %574 - OpBranch %519 - %520 = OpLabel + %559 = OpLoad %int %innerCol_4 + %560 = OpIAdd %int %554 %555 + OpStore %param_7 %560 + %561 = OpIAdd %int %556 %557 + OpStore %param_8 %561 + %562 = OpAccessChain %_ptr_Function_float %acc %558 %559 + %563 = OpLoad %float %562 + OpStore %param_9 %563 + %564 = OpFunctionCall %void %mm_write_i1_i1_f1_ %param_7 %param_8 %param_9 + OpBranch %552 + %552 = OpLabel + OpBranch %527 + %527 = OpLabel + %568 = OpLoad %int %innerCol_4 + %569 = OpIAdd %int %568 %int_1 + OpStore %innerCol_4 %569 + OpBranch %525 + %526 = OpLabel + OpBranch %518 + %518 = OpLabel + %570 = OpLoad %int %innerRow_4 + %571 = OpIAdd %int %570 %int_1 + OpStore %innerRow_4 %571 + OpBranch %516 + %517 = OpLabel OpReturn OpFunctionEnd - %main_1 = OpFunction %void None %575 - %577 = OpLabel + %main_1 = OpFunction %void None %572 + %574 = OpLabel %param_18 = OpVariable %_ptr_Function_int Function %11 %param_19 = OpVariable %_ptr_Function_int Function %11 %param_20 = OpVariable %_ptr_Function_int Function %11 - %581 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_1 %uint_1 - %582 = OpLoad %int %581 - OpStore %dimAOuter_1 %582 - %583 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_1 %uint_2 - %584 = OpLoad %int %583 - OpStore %dimInner_1 %584 - %585 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_2 %uint_2 - %586 = OpLoad %int %585 - OpStore %dimBOuter_1 %586 - %587 = OpAccessChain %_ptr_Private_uint %gl_GlobalInvocationID %uint_2 - %588 = OpLoad %uint %587 - %589 = OpBitcast %int %588 - OpStore %batch %589 - %590 = OpLoad %int %dimAOuter_1 - OpStore %param_18 %590 - %591 = OpLoad %int %dimInner_1 - OpStore %param_19 %591 - %592 = OpLoad %int %dimBOuter_1 - OpStore %param_20 %592 - %593 = OpFunctionCall %void %mm_matMul_i1_i1_i1_ %param_18 %param_19 %param_20 + %578 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_1 %uint_1 + %579 = OpLoad %int %578 + OpStore %dimAOuter_1 %579 + %580 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_1 %uint_2 + %581 = OpLoad %int %580 + OpStore %dimInner_1 %581 + %582 = OpAccessChain %_ptr_Uniform_int %x_48 %uint_2 %uint_2 + %583 = OpLoad %int %582 + OpStore %dimBOuter_1 %583 + %584 = OpAccessChain %_ptr_Private_uint %gl_GlobalInvocationID %uint_2 + %585 = OpLoad %uint %584 + %586 = OpBitcast %int %585 + OpStore %batch %586 + %587 = OpLoad %int %dimAOuter_1 + OpStore %param_18 %587 + %588 = OpLoad %int %dimInner_1 + OpStore %param_19 %588 + %589 = OpLoad %int %dimBOuter_1 + OpStore %param_20 %589 + %590 = OpFunctionCall %void %mm_matMul_i1_i1_i1_ %param_18 %param_19 %param_20 OpReturn OpFunctionEnd - %main_inner = OpFunction %void None %597 + %main_inner = OpFunction %void None %594 %gl_LocalInvocationID_param = OpFunctionParameter %v3uint %gl_GlobalInvocationID_param = OpFunctionParameter %v3uint %local_invocation_index = OpFunctionParameter %uint - %602 = OpLabel - %idx = OpVariable %_ptr_Function_uint Function %607 - %603 = OpUMod %uint %local_invocation_index %uint_1 - %604 = OpAccessChain %_ptr_Workgroup_float %mm_Bsub %local_invocation_index %603 - OpStore %604 %85 + %599 = OpLabel + %idx = OpVariable %_ptr_Function_uint Function %604 + %600 = OpUMod %uint %local_invocation_index %uint_1 + %601 = OpAccessChain %_ptr_Workgroup_float %mm_Bsub %local_invocation_index %600 + OpStore %601 %83 OpStore %idx %local_invocation_index + OpBranch %605 + %605 = OpLabel + OpLoopMerge %606 %607 None OpBranch %608 %608 = OpLabel - OpLoopMerge %609 %610 None - OpBranch %611 - %611 = OpLabel - %613 = OpLoad %uint %idx - %615 = OpULessThan %bool %613 %uint_4096 - %612 = OpLogicalNot %bool %615 - OpSelectionMerge %616 None - OpBranchConditional %612 %617 %616 - %617 = OpLabel - OpBranch %609 - %616 = OpLabel - %618 = OpLoad %uint %idx - %619 = OpUDiv %uint %618 %uint_64 + %610 = OpLoad %uint %idx + %612 = OpULessThan %bool %610 %uint_4096 + %609 = OpLogicalNot %bool %612 + OpSelectionMerge %613 None + OpBranchConditional %609 %614 %613 + %614 = OpLabel + OpBranch %606 + %613 = OpLabel + %615 = OpLoad %uint %idx + %616 = OpUDiv %uint %615 %uint_64 + %617 = OpLoad %uint %idx + %618 = OpUMod %uint %617 %uint_64 + %619 = OpAccessChain %_ptr_Workgroup_float %mm_Asub %616 %618 + OpStore %619 %83 + OpBranch %607 + %607 = OpLabel %620 = OpLoad %uint %idx - %621 = OpUMod %uint %620 %uint_64 - %622 = OpAccessChain %_ptr_Workgroup_float %mm_Asub %619 %621 - OpStore %622 %85 - OpBranch %610 - %610 = OpLabel - %623 = OpLoad %uint %idx - %624 = OpIAdd %uint %623 %uint_64 - OpStore %idx %624 - OpBranch %608 - %609 = OpLabel + %621 = OpIAdd %uint %620 %uint_64 + OpStore %idx %621 + OpBranch %605 + %606 = OpLabel OpControlBarrier %uint_2 %uint_2 %uint_264 OpStore %gl_LocalInvocationID %gl_LocalInvocationID_param OpStore %gl_GlobalInvocationID %gl_GlobalInvocationID_param - %626 = OpFunctionCall %void %main_1 + %623 = OpFunctionCall %void %main_1 OpReturn OpFunctionEnd - %main = OpFunction %void None %575 - %628 = OpLabel - %630 = OpLoad %v3uint %gl_LocalInvocationID_param_1 - %631 = OpLoad %v3uint %gl_GlobalInvocationID_param_1 - %632 = OpLoad %uint %local_invocation_index_1 - %629 = OpFunctionCall %void %main_inner %630 %631 %632 + %main = OpFunction %void None %572 + %625 = OpLabel + %627 = OpLoad %v3uint %gl_LocalInvocationID_param_1 + %628 = OpLoad %v3uint %gl_GlobalInvocationID_param_1 + %629 = OpLoad %uint %local_invocation_index_1 + %626 = OpFunctionCall %void %main_inner %627 %628 %629 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/948.wgsl.expected.spvasm b/test/tint/bug/tint/948.wgsl.expected.spvasm index e4dbc131e6..a3e66de216 100644 --- a/test/tint/bug/tint/948.wgsl.expected.spvasm +++ b/test/tint/bug/tint/948.wgsl.expected.spvasm @@ -13,10 +13,10 @@ bug/tint/948.wgsl:137:27 note: reading from module-scope private variable 'mt' m ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 386 +; Bound: 383 ; Schema: 0 OpCapability Shader - %138 = OpExtInstImport "GLSL.std.450" + %136 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %main "main" %tUV_param_1 %tileID_1_param_1 %levelUnits_param_1 %stageUnits_1_param_1 %vPosition_param_1 %vUV_param_1 %glFragColor_1_1 OpExecutionMode %main OriginUpperLeft @@ -181,30 +181,27 @@ bug/tint/948.wgsl:137:27 note: reading from module-scope private variable 'mt' m %uint_7 = OpConstant %uint 7 %_ptr_Uniform_float = OpTypePointer Uniform %float %66 = OpTypeSampledImage %23 - %float_0 = OpConstant %float 0 %float_0_25 = OpConstant %float 0.25 %float_0_5 = OpConstant %float 0.5 - %99 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %void = OpTypeVoid - %106 = OpTypeFunction %void + %104 = OpTypeFunction %void %_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Function_v2float = OpTypePointer Function %v2float %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int - %121 = OpConstantNull %int + %119 = OpConstantNull %int %_ptr_Function_mat4v4float = OpTypePointer Function %mat4v4float - %127 = OpConstantNull %mat4v4float + %125 = OpConstantNull %mat4v4float %_ptr_Function_v3float = OpTypePointer Function %v3float %uint_1 = OpConstant %uint 1 %float_1 = OpConstant %float 1 %uint_5 = OpConstant %uint 5 %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float - %151 = OpConstantComposite %v2float %float_1 %float_1 + %149 = OpConstantComposite %v2float %float_1 %float_1 %uint_4 = OpConstant %uint 4 - %int_0 = OpConstant %int 0 %int_2 = OpConstant %int 2 %bool = OpTypeBool - %184 = OpConstantComposite %v2float %float_0_5 %float_0_5 + %181 = OpConstantComposite %v2float %float_0_5 %float_0_5 %uint_0 = OpConstant %uint 0 %uint_2 = OpConstant %uint 2 %float_8 = OpConstant %float 8 @@ -214,7 +211,7 @@ bug/tint/948.wgsl:137:27 note: reading from module-scope private variable 'mt' m %uint_8 = OpConstant %uint 8 %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float %main_out = OpTypeStruct %v4float - %363 = OpTypeFunction %main_out %v2float %v2float %v2float %v2float %v3float %v2float + %360 = OpTypeFunction %main_out %v2float %v2float %v2float %v2float %v3float %v2float %getFrameData_f1_ = OpFunction %mat4v4float None %49 %frameID = OpFunctionParameter %_ptr_Function_float %53 = OpLabel @@ -228,56 +225,56 @@ bug/tint/948.wgsl:137:27 note: reading from module-scope private variable 'mt' m %64 = OpLoad %26 %frameMapSampler %65 = OpLoad %23 %frameMapTexture %67 = OpSampledImage %66 %65 %64 - %69 = OpCompositeConstruct %v2float %62 %float_0 - %63 = OpImageSampleImplicitLod %v4float %67 %69 Bias %float_0 - %70 = OpLoad %float %fX - %72 = OpLoad %26 %frameMapSampler - %73 = OpLoad %23 %frameMapTexture - %74 = OpSampledImage %66 %73 %72 - %76 = OpCompositeConstruct %v2float %70 %float_0_25 - %71 = OpImageSampleImplicitLod %v4float %74 %76 Bias %float_0 - %77 = OpLoad %float %fX - %79 = OpLoad %26 %frameMapSampler - %80 = OpLoad %23 %frameMapTexture - %81 = OpSampledImage %66 %80 %79 - %83 = OpCompositeConstruct %v2float %77 %float_0_5 - %78 = OpImageSampleImplicitLod %v4float %81 %83 Bias %float_0 - %84 = OpCompositeExtract %float %63 0 - %85 = OpCompositeExtract %float %63 1 - %86 = OpCompositeExtract %float %63 2 - %87 = OpCompositeExtract %float %63 3 - %88 = OpCompositeConstruct %v4float %84 %85 %86 %87 - %89 = OpCompositeExtract %float %71 0 - %90 = OpCompositeExtract %float %71 1 - %91 = OpCompositeExtract %float %71 2 - %92 = OpCompositeExtract %float %71 3 - %93 = OpCompositeConstruct %v4float %89 %90 %91 %92 - %94 = OpCompositeExtract %float %78 0 - %95 = OpCompositeExtract %float %78 1 - %96 = OpCompositeExtract %float %78 2 - %97 = OpCompositeExtract %float %78 3 - %98 = OpCompositeConstruct %v4float %94 %95 %96 %97 - %100 = OpCompositeExtract %float %99 0 - %101 = OpCompositeExtract %float %99 1 - %102 = OpCompositeExtract %float %99 2 - %103 = OpCompositeExtract %float %99 3 - %104 = OpCompositeConstruct %v4float %100 %101 %102 %103 - %105 = OpCompositeConstruct %mat4v4float %88 %93 %98 %104 - OpReturnValue %105 + %68 = OpCompositeConstruct %v2float %62 %37 + %63 = OpImageSampleImplicitLod %v4float %67 %68 Bias %37 + %69 = OpLoad %float %fX + %71 = OpLoad %26 %frameMapSampler + %72 = OpLoad %23 %frameMapTexture + %73 = OpSampledImage %66 %72 %71 + %75 = OpCompositeConstruct %v2float %69 %float_0_25 + %70 = OpImageSampleImplicitLod %v4float %73 %75 Bias %37 + %76 = OpLoad %float %fX + %78 = OpLoad %26 %frameMapSampler + %79 = OpLoad %23 %frameMapTexture + %80 = OpSampledImage %66 %79 %78 + %82 = OpCompositeConstruct %v2float %76 %float_0_5 + %77 = OpImageSampleImplicitLod %v4float %80 %82 Bias %37 + %83 = OpCompositeExtract %float %63 0 + %84 = OpCompositeExtract %float %63 1 + %85 = OpCompositeExtract %float %63 2 + %86 = OpCompositeExtract %float %63 3 + %87 = OpCompositeConstruct %v4float %83 %84 %85 %86 + %88 = OpCompositeExtract %float %70 0 + %89 = OpCompositeExtract %float %70 1 + %90 = OpCompositeExtract %float %70 2 + %91 = OpCompositeExtract %float %70 3 + %92 = OpCompositeConstruct %v4float %88 %89 %90 %91 + %93 = OpCompositeExtract %float %77 0 + %94 = OpCompositeExtract %float %77 1 + %95 = OpCompositeExtract %float %77 2 + %96 = OpCompositeExtract %float %77 3 + %97 = OpCompositeConstruct %v4float %93 %94 %95 %96 + %98 = OpCompositeExtract %float %15 0 + %99 = OpCompositeExtract %float %15 1 + %100 = OpCompositeExtract %float %15 2 + %101 = OpCompositeExtract %float %15 3 + %102 = OpCompositeConstruct %v4float %98 %99 %100 %101 + %103 = OpCompositeConstruct %mat4v4float %87 %92 %97 %102 + OpReturnValue %103 OpFunctionEnd - %main_1 = OpFunction %void None %106 - %109 = OpLabel + %main_1 = OpFunction %void None %104 + %107 = OpLabel %color = OpVariable %_ptr_Function_v4float Function %15 %tileUV = OpVariable %_ptr_Function_v2float Function %29 %tileID = OpVariable %_ptr_Function_v2float Function %29 %sheetUnits = OpVariable %_ptr_Function_v2float Function %29 %spriteUnits = OpVariable %_ptr_Function_float Function %37 %stageUnits = OpVariable %_ptr_Function_v2float Function %29 - %i = OpVariable %_ptr_Function_int Function %121 + %i = OpVariable %_ptr_Function_int Function %119 %frameID_1 = OpVariable %_ptr_Function_float Function %37 %animationData = OpVariable %_ptr_Function_v4float Function %15 %f = OpVariable %_ptr_Function_float Function %37 - %frameData = OpVariable %_ptr_Function_mat4v4float Function %127 + %frameData = OpVariable %_ptr_Function_mat4v4float Function %125 %param = OpVariable %_ptr_Function_float Function %37 %frameSize = OpVariable %_ptr_Function_v2float Function %29 %offset_1 = OpVariable %_ptr_Function_v2float Function %29 @@ -285,310 +282,310 @@ bug/tint/948.wgsl:137:27 note: reading from module-scope private variable 'mt' m %nc = OpVariable %_ptr_Function_v4float Function %15 %alpha = OpVariable %_ptr_Function_float Function %37 %mixed = OpVariable %_ptr_Function_v3float Function %47 - OpStore %color %99 - %136 = OpLoad %v2float %tUV - %137 = OpExtInst %v2float %138 Fract %136 - OpStore %tileUV %137 + OpStore %color %15 + %134 = OpLoad %v2float %tUV + %135 = OpExtInst %v2float %136 Fract %134 + OpStore %tileUV %135 + %138 = OpAccessChain %_ptr_Function_float %tileUV %uint_1 + %139 = OpLoad %float %138 %140 = OpAccessChain %_ptr_Function_float %tileUV %uint_1 - %141 = OpLoad %float %140 - %142 = OpAccessChain %_ptr_Function_float %tileUV %uint_1 - %144 = OpFSub %float %float_1 %141 - OpStore %142 %144 - %145 = OpLoad %v2float %tUV - %146 = OpExtInst %v2float %138 Floor %145 - OpStore %tileID %146 - %149 = OpAccessChain %_ptr_Uniform_v2float %x_20 %uint_5 - %150 = OpLoad %v2float %149 - %152 = OpFDiv %v2float %151 %150 - OpStore %sheetUnits %152 - %153 = OpAccessChain %_ptr_Uniform_float %x_20 %uint_7 - %154 = OpLoad %float %153 - %155 = OpFDiv %float %float_1 %154 - OpStore %spriteUnits %155 - %157 = OpAccessChain %_ptr_Uniform_v2float %x_20 %uint_4 - %158 = OpLoad %v2float %157 - %159 = OpFDiv %v2float %151 %158 - OpStore %stageUnits %159 - OpStore %i %int_0 + %142 = OpFSub %float %float_1 %139 + OpStore %140 %142 + %143 = OpLoad %v2float %tUV + %144 = OpExtInst %v2float %136 Floor %143 + OpStore %tileID %144 + %147 = OpAccessChain %_ptr_Uniform_v2float %x_20 %uint_5 + %148 = OpLoad %v2float %147 + %150 = OpFDiv %v2float %149 %148 + OpStore %sheetUnits %150 + %151 = OpAccessChain %_ptr_Uniform_float %x_20 %uint_7 + %152 = OpLoad %float %151 + %153 = OpFDiv %float %float_1 %152 + OpStore %spriteUnits %153 + %155 = OpAccessChain %_ptr_Uniform_v2float %x_20 %uint_4 + %156 = OpLoad %v2float %155 + %157 = OpFDiv %v2float %149 %156 + OpStore %stageUnits %157 + OpStore %i %119 + OpBranch %158 + %158 = OpLabel + OpLoopMerge %159 %160 None OpBranch %161 %161 = OpLabel - OpLoopMerge %162 %163 None - OpBranch %164 - %164 = OpLabel - %165 = OpLoad %int %i - %167 = OpSLessThan %bool %165 %int_2 - OpSelectionMerge %169 None - OpBranchConditional %167 %170 %171 - %170 = OpLabel - OpBranch %169 - %171 = OpLabel - OpBranch %162 - %169 = OpLabel - %172 = OpLoad %int %i - OpSelectionMerge %173 None - OpSwitch %172 %174 1 %175 0 %176 - %175 = OpLabel - %177 = OpLoad %v2float %tileID - %178 = OpAccessChain %_ptr_Uniform_v2float %x_20 %uint_4 - %179 = OpLoad %v2float %178 - %181 = OpLoad %26 %tileMapsSampler - %182 = OpLoad %23 %tileMapsTexture1 - %183 = OpSampledImage %66 %182 %181 - %185 = OpFAdd %v2float %177 %184 - %186 = OpFDiv %v2float %185 %179 - %180 = OpImageSampleImplicitLod %v4float %183 %186 Bias %float_0 - %187 = OpCompositeExtract %float %180 0 - OpStore %frameID_1 %187 - OpBranch %173 - %176 = OpLabel - %188 = OpLoad %v2float %tileID - %189 = OpAccessChain %_ptr_Uniform_v2float %x_20 %uint_4 - %190 = OpLoad %v2float %189 - %192 = OpLoad %26 %tileMapsSampler - %193 = OpLoad %23 %tileMapsTexture0 - %194 = OpSampledImage %66 %193 %192 - %195 = OpFAdd %v2float %188 %184 - %196 = OpFDiv %v2float %195 %190 - %191 = OpImageSampleImplicitLod %v4float %194 %196 Bias %float_0 - %197 = OpCompositeExtract %float %191 0 - OpStore %frameID_1 %197 - OpBranch %173 - %174 = OpLabel - OpBranch %173 + %162 = OpLoad %int %i + %164 = OpSLessThan %bool %162 %int_2 + OpSelectionMerge %166 None + OpBranchConditional %164 %167 %168 + %167 = OpLabel + OpBranch %166 + %168 = OpLabel + OpBranch %159 + %166 = OpLabel + %169 = OpLoad %int %i + OpSelectionMerge %170 None + OpSwitch %169 %171 1 %172 0 %173 + %172 = OpLabel + %174 = OpLoad %v2float %tileID + %175 = OpAccessChain %_ptr_Uniform_v2float %x_20 %uint_4 + %176 = OpLoad %v2float %175 + %178 = OpLoad %26 %tileMapsSampler + %179 = OpLoad %23 %tileMapsTexture1 + %180 = OpSampledImage %66 %179 %178 + %182 = OpFAdd %v2float %174 %181 + %183 = OpFDiv %v2float %182 %176 + %177 = OpImageSampleImplicitLod %v4float %180 %183 Bias %37 + %184 = OpCompositeExtract %float %177 0 + OpStore %frameID_1 %184 + OpBranch %170 %173 = OpLabel - %198 = OpLoad %float %frameID_1 - %199 = OpAccessChain %_ptr_Uniform_float %x_20 %uint_7 - %200 = OpLoad %float %199 - %202 = OpLoad %26 %animationMapSampler - %203 = OpLoad %23 %animationMapTexture - %204 = OpSampledImage %66 %203 %202 - %205 = OpFAdd %float %198 %float_0_5 - %206 = OpFDiv %float %205 %200 - %207 = OpCompositeConstruct %v2float %206 %float_0 - %201 = OpImageSampleImplicitLod %v4float %204 %207 Bias %float_0 - OpStore %animationData %201 - %208 = OpAccessChain %_ptr_Function_float %animationData %uint_1 - %209 = OpLoad %float %208 - %210 = OpFOrdGreaterThan %bool %209 %float_0 - OpSelectionMerge %211 None - OpBranchConditional %210 %212 %211 - %212 = OpLabel - %214 = OpAccessChain %_ptr_Uniform_float %x_20 %uint_0 + %185 = OpLoad %v2float %tileID + %186 = OpAccessChain %_ptr_Uniform_v2float %x_20 %uint_4 + %187 = OpLoad %v2float %186 + %189 = OpLoad %26 %tileMapsSampler + %190 = OpLoad %23 %tileMapsTexture0 + %191 = OpSampledImage %66 %190 %189 + %192 = OpFAdd %v2float %185 %181 + %193 = OpFDiv %v2float %192 %187 + %188 = OpImageSampleImplicitLod %v4float %191 %193 Bias %37 + %194 = OpCompositeExtract %float %188 0 + OpStore %frameID_1 %194 + OpBranch %170 + %171 = OpLabel + OpBranch %170 + %170 = OpLabel + %195 = OpLoad %float %frameID_1 + %196 = OpAccessChain %_ptr_Uniform_float %x_20 %uint_7 + %197 = OpLoad %float %196 + %199 = OpLoad %26 %animationMapSampler + %200 = OpLoad %23 %animationMapTexture + %201 = OpSampledImage %66 %200 %199 + %202 = OpFAdd %float %195 %float_0_5 + %203 = OpFDiv %float %202 %197 + %204 = OpCompositeConstruct %v2float %203 %37 + %198 = OpImageSampleImplicitLod %v4float %201 %204 Bias %37 + OpStore %animationData %198 + %205 = OpAccessChain %_ptr_Function_float %animationData %uint_1 + %206 = OpLoad %float %205 + %207 = OpFOrdGreaterThan %bool %206 %37 + OpSelectionMerge %208 None + OpBranchConditional %207 %209 %208 + %209 = OpLabel + %211 = OpAccessChain %_ptr_Uniform_float %x_20 %uint_0 + %212 = OpLoad %float %211 + %214 = OpAccessChain %_ptr_Function_float %animationData %uint_2 %215 = OpLoad %float %214 - %217 = OpAccessChain %_ptr_Function_float %animationData %uint_2 - %218 = OpLoad %float %217 - %219 = OpFMul %float %215 %218 - %220 = OpFRem %float %219 %float_1 - OpStore %mt %220 - OpStore %f %float_0 + %216 = OpFMul %float %212 %215 + %217 = OpFRem %float %216 %float_1 + OpStore %mt %217 + OpStore %f %37 + OpBranch %218 + %218 = OpLabel + OpLoopMerge %219 %220 None OpBranch %221 %221 = OpLabel - OpLoopMerge %222 %223 None - OpBranch %224 - %224 = OpLabel - %225 = OpLoad %float %f - %227 = OpFOrdLessThan %bool %225 %float_8 - OpSelectionMerge %228 None - OpBranchConditional %227 %229 %230 - %229 = OpLabel - OpBranch %228 - %230 = OpLabel - OpBranch %222 - %228 = OpLabel - %231 = OpAccessChain %_ptr_Function_float %animationData %uint_1 - %232 = OpLoad %float %231 - %233 = OpLoad %float %mt - %234 = OpFOrdGreaterThan %bool %232 %233 - OpSelectionMerge %235 None - OpBranchConditional %234 %236 %235 - %236 = OpLabel - %237 = OpAccessChain %_ptr_Function_float %animationData %uint_0 + %222 = OpLoad %float %f + %224 = OpFOrdLessThan %bool %222 %float_8 + OpSelectionMerge %225 None + OpBranchConditional %224 %226 %227 + %226 = OpLabel + OpBranch %225 + %227 = OpLabel + OpBranch %219 + %225 = OpLabel + %228 = OpAccessChain %_ptr_Function_float %animationData %uint_1 + %229 = OpLoad %float %228 + %230 = OpLoad %float %mt + %231 = OpFOrdGreaterThan %bool %229 %230 + OpSelectionMerge %232 None + OpBranchConditional %231 %233 %232 + %233 = OpLabel + %234 = OpAccessChain %_ptr_Function_float %animationData %uint_0 + %235 = OpLoad %float %234 + OpStore %frameID_1 %235 + OpBranch %219 + %232 = OpLabel + %236 = OpLoad %float %frameID_1 + %237 = OpAccessChain %_ptr_Uniform_float %x_20 %uint_7 %238 = OpLoad %float %237 - OpStore %frameID_1 %238 - OpBranch %222 - %235 = OpLabel - %239 = OpLoad %float %frameID_1 - %240 = OpAccessChain %_ptr_Uniform_float %x_20 %uint_7 - %241 = OpLoad %float %240 - %242 = OpLoad %float %f - %244 = OpLoad %26 %animationMapSampler - %245 = OpLoad %23 %animationMapTexture - %246 = OpSampledImage %66 %245 %244 - %247 = OpFAdd %float %239 %float_0_5 - %248 = OpFDiv %float %247 %241 - %250 = OpFMul %float %float_0_125 %242 - %251 = OpCompositeConstruct %v2float %248 %250 - %243 = OpImageSampleImplicitLod %v4float %246 %251 Bias %float_0 - OpStore %animationData %243 - OpBranch %223 - %223 = OpLabel - %252 = OpLoad %float %f - %253 = OpFAdd %float %252 %float_1 - OpStore %f %253 - OpBranch %221 - %222 = OpLabel - OpBranch %211 - %211 = OpLabel - %254 = OpLoad %float %frameID_1 - %255 = OpFAdd %float %254 %float_0_5 - OpStore %param %255 - %256 = OpFunctionCall %mat4v4float %getFrameData_f1_ %param - OpStore %frameData %256 - %258 = OpAccessChain %_ptr_Function_v4float %frameData %int_0 - %259 = OpLoad %v4float %258 - %260 = OpAccessChain %_ptr_Uniform_v2float %x_20 %uint_5 - %261 = OpLoad %v2float %260 - %262 = OpCompositeExtract %float %259 3 - %263 = OpCompositeExtract %float %259 2 - %264 = OpCompositeConstruct %v2float %262 %263 - %265 = OpFDiv %v2float %264 %261 - OpStore %frameSize %265 - %266 = OpAccessChain %_ptr_Function_v4float %frameData %int_0 - %267 = OpLoad %v4float %266 - %268 = OpLoad %v2float %sheetUnits - %269 = OpCompositeExtract %float %267 0 - %270 = OpCompositeExtract %float %267 1 - %271 = OpCompositeConstruct %v2float %269 %270 - %272 = OpFMul %v2float %271 %268 - OpStore %offset_1 %272 - %273 = OpAccessChain %_ptr_Function_v4float %frameData %int_2 - %274 = OpLoad %v4float %273 - %275 = OpAccessChain %_ptr_Function_v4float %frameData %int_0 - %276 = OpLoad %v4float %275 - %277 = OpCompositeExtract %float %274 0 - %278 = OpCompositeExtract %float %274 1 + %239 = OpLoad %float %f + %241 = OpLoad %26 %animationMapSampler + %242 = OpLoad %23 %animationMapTexture + %243 = OpSampledImage %66 %242 %241 + %244 = OpFAdd %float %236 %float_0_5 + %245 = OpFDiv %float %244 %238 + %247 = OpFMul %float %float_0_125 %239 + %248 = OpCompositeConstruct %v2float %245 %247 + %240 = OpImageSampleImplicitLod %v4float %243 %248 Bias %37 + OpStore %animationData %240 + OpBranch %220 + %220 = OpLabel + %249 = OpLoad %float %f + %250 = OpFAdd %float %249 %float_1 + OpStore %f %250 + OpBranch %218 + %219 = OpLabel + OpBranch %208 + %208 = OpLabel + %251 = OpLoad %float %frameID_1 + %252 = OpFAdd %float %251 %float_0_5 + OpStore %param %252 + %253 = OpFunctionCall %mat4v4float %getFrameData_f1_ %param + OpStore %frameData %253 + %255 = OpAccessChain %_ptr_Function_v4float %frameData %119 + %256 = OpLoad %v4float %255 + %257 = OpAccessChain %_ptr_Uniform_v2float %x_20 %uint_5 + %258 = OpLoad %v2float %257 + %259 = OpCompositeExtract %float %256 3 + %260 = OpCompositeExtract %float %256 2 + %261 = OpCompositeConstruct %v2float %259 %260 + %262 = OpFDiv %v2float %261 %258 + OpStore %frameSize %262 + %263 = OpAccessChain %_ptr_Function_v4float %frameData %119 + %264 = OpLoad %v4float %263 + %265 = OpLoad %v2float %sheetUnits + %266 = OpCompositeExtract %float %264 0 + %267 = OpCompositeExtract %float %264 1 + %268 = OpCompositeConstruct %v2float %266 %267 + %269 = OpFMul %v2float %268 %265 + OpStore %offset_1 %269 + %270 = OpAccessChain %_ptr_Function_v4float %frameData %int_2 + %271 = OpLoad %v4float %270 + %272 = OpAccessChain %_ptr_Function_v4float %frameData %119 + %273 = OpLoad %v4float %272 + %274 = OpCompositeExtract %float %271 0 + %275 = OpCompositeExtract %float %271 1 + %276 = OpCompositeConstruct %v2float %274 %275 + %277 = OpCompositeExtract %float %273 3 + %278 = OpCompositeExtract %float %273 2 %279 = OpCompositeConstruct %v2float %277 %278 - %280 = OpCompositeExtract %float %276 3 - %281 = OpCompositeExtract %float %276 2 - %282 = OpCompositeConstruct %v2float %280 %281 - %283 = OpFDiv %v2float %279 %282 - OpStore %ratio %283 - %284 = OpAccessChain %_ptr_Function_float %frameData %int_2 %uint_2 - %285 = OpLoad %float %284 - %286 = OpFOrdEqual %bool %285 %float_1 - OpSelectionMerge %287 None - OpBranchConditional %286 %288 %287 - %288 = OpLabel - %289 = OpLoad %v2float %tileUV - %290 = OpCompositeExtract %float %289 1 - %291 = OpCompositeExtract %float %289 0 - %292 = OpCompositeConstruct %v2float %290 %291 - OpStore %tileUV %292 - OpBranch %287 - %287 = OpLabel - %293 = OpLoad %int %i - %294 = OpIEqual %bool %293 %int_0 - OpSelectionMerge %295 None - OpBranchConditional %294 %296 %297 - %296 = OpLabel - %298 = OpLoad %v2float %tileUV - %299 = OpLoad %v2float %frameSize - %300 = OpLoad %v2float %offset_1 - %302 = OpLoad %26 %spriteSheetSampler - %303 = OpLoad %23 %spriteSheetTexture - %304 = OpSampledImage %66 %303 %302 - %305 = OpFMul %v2float %298 %299 - %306 = OpFAdd %v2float %305 %300 - %301 = OpImageSampleImplicitLod %v4float %304 %306 - OpStore %color %301 - OpBranch %295 - %297 = OpLabel - %307 = OpLoad %v2float %tileUV - %308 = OpLoad %v2float %frameSize - %309 = OpLoad %v2float %offset_1 - %311 = OpLoad %26 %spriteSheetSampler - %312 = OpLoad %23 %spriteSheetTexture - %313 = OpSampledImage %66 %312 %311 - %314 = OpFMul %v2float %307 %308 - %315 = OpFAdd %v2float %314 %309 - %310 = OpImageSampleImplicitLod %v4float %313 %315 - OpStore %nc %310 - %317 = OpAccessChain %_ptr_Function_float %color %uint_3 - %318 = OpLoad %float %317 - %319 = OpAccessChain %_ptr_Function_float %nc %uint_3 - %320 = OpLoad %float %319 - %322 = OpFAdd %float %318 %320 - %321 = OpExtInst %float %138 NMin %322 %float_1 - OpStore %alpha %321 - %323 = OpLoad %v4float %color - %324 = OpLoad %v4float %nc - %325 = OpAccessChain %_ptr_Function_float %nc %uint_3 - %326 = OpLoad %float %325 - %328 = OpCompositeExtract %float %323 0 - %329 = OpCompositeExtract %float %323 1 - %330 = OpCompositeExtract %float %323 2 - %331 = OpCompositeConstruct %v3float %328 %329 %330 - %332 = OpCompositeExtract %float %324 0 - %333 = OpCompositeExtract %float %324 1 - %334 = OpCompositeExtract %float %324 2 - %335 = OpCompositeConstruct %v3float %332 %333 %334 - %336 = OpCompositeConstruct %v3float %326 %326 %326 - %327 = OpExtInst %v3float %138 FMix %331 %335 %336 - OpStore %mixed %327 - %337 = OpLoad %v3float %mixed - %338 = OpLoad %float %alpha - %339 = OpCompositeExtract %float %337 0 - %340 = OpCompositeExtract %float %337 1 - %341 = OpCompositeExtract %float %337 2 - %342 = OpCompositeConstruct %v4float %339 %340 %341 %338 - OpStore %color %342 - OpBranch %295 - %295 = OpLabel - OpBranch %163 - %163 = OpLabel - %343 = OpLoad %int %i - %345 = OpIAdd %int %343 %int_1 - OpStore %i %345 - OpBranch %161 - %162 = OpLabel - %348 = OpAccessChain %_ptr_Uniform_v3float %x_20 %uint_8 - %349 = OpLoad %v3float %348 - %350 = OpLoad %v4float %color - %351 = OpCompositeExtract %float %350 0 - %352 = OpCompositeExtract %float %350 1 - %353 = OpCompositeExtract %float %350 2 - %354 = OpCompositeConstruct %v3float %351 %352 %353 - %355 = OpFMul %v3float %354 %349 - %356 = OpLoad %v4float %color - %357 = OpCompositeExtract %float %355 0 - %358 = OpCompositeExtract %float %355 1 - %359 = OpCompositeExtract %float %355 2 - %360 = OpCompositeExtract %float %356 3 - %361 = OpCompositeConstruct %v4float %357 %358 %359 %360 - OpStore %color %361 - %362 = OpLoad %v4float %color - OpStore %glFragColor %362 + %280 = OpFDiv %v2float %276 %279 + OpStore %ratio %280 + %281 = OpAccessChain %_ptr_Function_float %frameData %int_2 %uint_2 + %282 = OpLoad %float %281 + %283 = OpFOrdEqual %bool %282 %float_1 + OpSelectionMerge %284 None + OpBranchConditional %283 %285 %284 + %285 = OpLabel + %286 = OpLoad %v2float %tileUV + %287 = OpCompositeExtract %float %286 1 + %288 = OpCompositeExtract %float %286 0 + %289 = OpCompositeConstruct %v2float %287 %288 + OpStore %tileUV %289 + OpBranch %284 + %284 = OpLabel + %290 = OpLoad %int %i + %291 = OpIEqual %bool %290 %119 + OpSelectionMerge %292 None + OpBranchConditional %291 %293 %294 + %293 = OpLabel + %295 = OpLoad %v2float %tileUV + %296 = OpLoad %v2float %frameSize + %297 = OpLoad %v2float %offset_1 + %299 = OpLoad %26 %spriteSheetSampler + %300 = OpLoad %23 %spriteSheetTexture + %301 = OpSampledImage %66 %300 %299 + %302 = OpFMul %v2float %295 %296 + %303 = OpFAdd %v2float %302 %297 + %298 = OpImageSampleImplicitLod %v4float %301 %303 + OpStore %color %298 + OpBranch %292 + %294 = OpLabel + %304 = OpLoad %v2float %tileUV + %305 = OpLoad %v2float %frameSize + %306 = OpLoad %v2float %offset_1 + %308 = OpLoad %26 %spriteSheetSampler + %309 = OpLoad %23 %spriteSheetTexture + %310 = OpSampledImage %66 %309 %308 + %311 = OpFMul %v2float %304 %305 + %312 = OpFAdd %v2float %311 %306 + %307 = OpImageSampleImplicitLod %v4float %310 %312 + OpStore %nc %307 + %314 = OpAccessChain %_ptr_Function_float %color %uint_3 + %315 = OpLoad %float %314 + %316 = OpAccessChain %_ptr_Function_float %nc %uint_3 + %317 = OpLoad %float %316 + %319 = OpFAdd %float %315 %317 + %318 = OpExtInst %float %136 NMin %319 %float_1 + OpStore %alpha %318 + %320 = OpLoad %v4float %color + %321 = OpLoad %v4float %nc + %322 = OpAccessChain %_ptr_Function_float %nc %uint_3 + %323 = OpLoad %float %322 + %325 = OpCompositeExtract %float %320 0 + %326 = OpCompositeExtract %float %320 1 + %327 = OpCompositeExtract %float %320 2 + %328 = OpCompositeConstruct %v3float %325 %326 %327 + %329 = OpCompositeExtract %float %321 0 + %330 = OpCompositeExtract %float %321 1 + %331 = OpCompositeExtract %float %321 2 + %332 = OpCompositeConstruct %v3float %329 %330 %331 + %333 = OpCompositeConstruct %v3float %323 %323 %323 + %324 = OpExtInst %v3float %136 FMix %328 %332 %333 + OpStore %mixed %324 + %334 = OpLoad %v3float %mixed + %335 = OpLoad %float %alpha + %336 = OpCompositeExtract %float %334 0 + %337 = OpCompositeExtract %float %334 1 + %338 = OpCompositeExtract %float %334 2 + %339 = OpCompositeConstruct %v4float %336 %337 %338 %335 + OpStore %color %339 + OpBranch %292 + %292 = OpLabel + OpBranch %160 + %160 = OpLabel + %340 = OpLoad %int %i + %342 = OpIAdd %int %340 %int_1 + OpStore %i %342 + OpBranch %158 + %159 = OpLabel + %345 = OpAccessChain %_ptr_Uniform_v3float %x_20 %uint_8 + %346 = OpLoad %v3float %345 + %347 = OpLoad %v4float %color + %348 = OpCompositeExtract %float %347 0 + %349 = OpCompositeExtract %float %347 1 + %350 = OpCompositeExtract %float %347 2 + %351 = OpCompositeConstruct %v3float %348 %349 %350 + %352 = OpFMul %v3float %351 %346 + %353 = OpLoad %v4float %color + %354 = OpCompositeExtract %float %352 0 + %355 = OpCompositeExtract %float %352 1 + %356 = OpCompositeExtract %float %352 2 + %357 = OpCompositeExtract %float %353 3 + %358 = OpCompositeConstruct %v4float %354 %355 %356 %357 + OpStore %color %358 + %359 = OpLoad %v4float %color + OpStore %glFragColor %359 OpReturn OpFunctionEnd - %main_inner = OpFunction %main_out None %363 + %main_inner = OpFunction %main_out None %360 %tUV_param = OpFunctionParameter %v2float %tileID_1_param = OpFunctionParameter %v2float %levelUnits_param = OpFunctionParameter %v2float %stageUnits_1_param = OpFunctionParameter %v2float %vPosition_param = OpFunctionParameter %v3float %vUV_param = OpFunctionParameter %v2float - %372 = OpLabel + %369 = OpLabel OpStore %tUV %tUV_param OpStore %tileID_1 %tileID_1_param OpStore %levelUnits %levelUnits_param OpStore %stageUnits_1 %stageUnits_1_param OpStore %vPosition %vPosition_param OpStore %vUV %vUV_param - %373 = OpFunctionCall %void %main_1 - %374 = OpLoad %v4float %glFragColor - %375 = OpCompositeConstruct %main_out %374 - OpReturnValue %375 + %370 = OpFunctionCall %void %main_1 + %371 = OpLoad %v4float %glFragColor + %372 = OpCompositeConstruct %main_out %371 + OpReturnValue %372 OpFunctionEnd - %main = OpFunction %void None %106 - %377 = OpLabel - %379 = OpLoad %v2float %tUV_param_1 - %380 = OpLoad %v2float %tileID_1_param_1 - %381 = OpLoad %v2float %levelUnits_param_1 - %382 = OpLoad %v2float %stageUnits_1_param_1 - %383 = OpLoad %v3float %vPosition_param_1 - %384 = OpLoad %v2float %vUV_param_1 - %378 = OpFunctionCall %main_out %main_inner %379 %380 %381 %382 %383 %384 - %385 = OpCompositeExtract %v4float %378 0 - OpStore %glFragColor_1_1 %385 + %main = OpFunction %void None %104 + %374 = OpLabel + %376 = OpLoad %v2float %tUV_param_1 + %377 = OpLoad %v2float %tileID_1_param_1 + %378 = OpLoad %v2float %levelUnits_param_1 + %379 = OpLoad %v2float %stageUnits_1_param_1 + %380 = OpLoad %v3float %vPosition_param_1 + %381 = OpLoad %v2float %vUV_param_1 + %375 = OpFunctionCall %main_out %main_inner %376 %377 %378 %379 %380 %381 + %382 = OpCompositeExtract %v4float %375 0 + OpStore %glFragColor_1_1 %382 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/949.wgsl.expected.spvasm b/test/tint/bug/tint/949.wgsl.expected.spvasm index 7e6d9bda16..bdee2f548c 100644 --- a/test/tint/bug/tint/949.wgsl.expected.spvasm +++ b/test/tint/bug/tint/949.wgsl.expected.spvasm @@ -13,7 +13,7 @@ bug/tint/949.wgsl:308:27 note: reading from module-scope private variable 'v_out ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 675 +; Bound: 670 ; Schema: 0 OpCapability Shader %88 = OpExtInstImport "GLSL.std.450" @@ -280,7 +280,7 @@ bug/tint/949.wgsl:308:27 note: reading from module-scope private variable 'v_out %152 = OpTypeFunction %mat3v3float %_ptr_Function_mat3v3float %161 = OpConstantNull %mat3v3float %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %164 = OpConstantNull %int %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 %uint_2 = OpConstant %uint 2 @@ -294,31 +294,26 @@ bug/tint/949.wgsl:308:27 note: reading from module-scope private variable 'v_out %_ptr_Function_lightingInfo = OpTypePointer Function %lightingInfo %261 = OpConstantNull %lightingInfo %float_0_5 = OpConstant %float 0.5 - %float_0 = OpConstant %float 0 %void = OpTypeVoid - %311 = OpTypeFunction %void + %310 = OpTypeFunction %void %_ptr_Function_int = OpTypePointer Function %int - %342 = OpConstantNull %int %float_100 = OpConstant %float 100 - %371 = OpConstantComposite %v3float %float_0_5 %float_0_5 %float_0_5 - %376 = OpTypeSampledImage %25 + %369 = OpConstantComposite %v3float %float_0_5 %float_0_5 %float_0_5 + %374 = OpTypeSampledImage %25 %uint_6 = OpConstant %uint 6 %_ptr_Uniform_float = OpTypePointer Uniform %float %uint_4 = OpConstant %uint 4 %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float - %399 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 - %400 = OpConstantComposite %v2float %float_0 %float_0 %uint_8 = OpConstant %uint 8 %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %uint_5 = OpConstant %uint 5 %float_15 = OpConstant %float 15 %float_n11 = OpConstant %float -11 %int_15 = OpConstant %int 15 - %593 = OpConstantComposite %v3float %float_0 %float_0 %float_0 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float %uint_3 = OpConstant %uint 3 %main_out = OpTypeStruct %v4float - %654 = OpTypeFunction %main_out %v2float %v4float %bool %v2float %v4float + %649 = OpTypeFunction %main_out %v2float %v4float %bool %v2float %v4float %cotangent_frame_vf3_vf3_vf2_vf2_ = OpFunction %mat3v3float None %52 %normal_1 = OpFunctionParameter %_ptr_Function_v3float %p = OpFunctionParameter %_ptr_Function_v3float @@ -422,7 +417,7 @@ bug/tint/949.wgsl:308:27 note: reading from module-scope private variable 'v_out %i1 = OpVariable %_ptr_Function_v3float Function %22 %i2 = OpVariable %_ptr_Function_v3float Function %22 %outMatrix = OpVariable %_ptr_Function_mat3v3float Function %161 - %165 = OpAccessChain %_ptr_Function_v3float %inMatrix %int_0 + %165 = OpAccessChain %_ptr_Function_v3float %inMatrix %164 %166 = OpLoad %v3float %165 OpStore %i0 %166 %169 = OpAccessChain %_ptr_Function_v3float %inMatrix %int_1 @@ -540,24 +535,24 @@ bug/tint/949.wgsl:308:27 note: reading from module-scope private variable 'v_out OpStore %angleW %288 %295 = OpLoad %v3float %vNormal %296 = OpLoad %v3float %angleW - %299 = OpDot %float %295 %296 - %297 = OpExtInst %float %88 NMax %float_0 %299 + %298 = OpDot %float %295 %296 + %297 = OpExtInst %float %88 NMax %18 %298 OpStore %specComp %297 - %300 = OpLoad %float %specComp - %302 = OpLoad %float %glossiness - %304 = OpExtInst %float %88 NMax %float_1 %302 - %303 = OpExtInst %float %88 Pow %300 %304 - OpStore %specComp %303 - %305 = OpLoad %float %specComp - %307 = OpLoad %v3float %specularColor - %308 = OpAccessChain %_ptr_Function_v3float %result %uint_1 - %309 = OpVectorTimesScalar %v3float %307 %305 - OpStore %308 %309 - %310 = OpLoad %lightingInfo %result - OpReturnValue %310 + %299 = OpLoad %float %specComp + %301 = OpLoad %float %glossiness + %303 = OpExtInst %float %88 NMax %float_1 %301 + %302 = OpExtInst %float %88 Pow %299 %303 + OpStore %specComp %302 + %304 = OpLoad %float %specComp + %306 = OpLoad %v3float %specularColor + %307 = OpAccessChain %_ptr_Function_v3float %result %uint_1 + %308 = OpVectorTimesScalar %v3float %306 %304 + OpStore %307 %308 + %309 = OpLoad %lightingInfo %result + OpReturnValue %309 OpFunctionEnd - %main_1 = OpFunction %void None %311 - %314 = OpLabel + %main_1 = OpFunction %void None %310 + %313 = OpLabel %tempTextureRead = OpVariable %_ptr_Function_v4float Function %15 %rgb = OpVariable %_ptr_Function_v3float Function %22 %output5 = OpVariable %_ptr_Function_v3float Function %22 @@ -583,7 +578,7 @@ bug/tint/949.wgsl:308:27 note: reading from module-scope private variable 'v_out %vLastOffset = OpVariable %_ptr_Function_v2float Function %31 %lastSampledHeight = OpVariable %_ptr_Function_float Function %18 %currSampledHeight = OpVariable %_ptr_Function_float Function %18 - %i = OpVariable %_ptr_Function_int Function %342 + %i = OpVariable %_ptr_Function_int Function %164 %delta1 = OpVariable %_ptr_Function_float Function %18 %delta2 = OpVariable %_ptr_Function_float Function %18 %ratio = OpVariable %_ptr_Function_float Function %18 @@ -612,371 +607,371 @@ bug/tint/949.wgsl:308:27 note: reading from module-scope private variable 'v_out %specularOutput = OpVariable %_ptr_Function_v3float Function %22 %output3 = OpVariable %_ptr_Function_v3float Function %22 OpStore %u_Float %float_100 - OpStore %u_Color %371 - %372 = OpLoad %v2float %vMainuv - %374 = OpLoad %28 %TextureSamplerSampler - %375 = OpLoad %25 %TextureSamplerTexture - %377 = OpSampledImage %376 %375 %374 - %373 = OpImageSampleImplicitLod %v4float %377 %372 - OpStore %tempTextureRead %373 - %378 = OpLoad %v4float %tempTextureRead - %381 = OpAccessChain %_ptr_Uniform_float %x_269 %uint_6 - %382 = OpLoad %float %381 - %383 = OpCompositeExtract %float %378 0 - %384 = OpCompositeExtract %float %378 1 - %385 = OpCompositeExtract %float %378 2 - %386 = OpCompositeConstruct %v3float %383 %384 %385 - %387 = OpVectorTimesScalar %v3float %386 %382 - OpStore %rgb %387 - %390 = OpAccessChain %_ptr_Uniform_v3float %x_269 %uint_4 - %391 = OpLoad %v3float %390 - %392 = OpLoad %v4float %v_output1 - %394 = OpCompositeExtract %float %392 0 - %395 = OpCompositeExtract %float %392 1 - %396 = OpCompositeExtract %float %392 2 - %397 = OpCompositeConstruct %v3float %394 %395 %396 - %398 = OpFSub %v3float %391 %397 - %393 = OpExtInst %v3float %88 Normalize %398 - OpStore %output5 %393 - OpStore %output4 %399 - OpStore %uvOffset %400 - %401 = OpAccessChain %_ptr_Uniform_float %x_269 %uint_2 - %402 = OpLoad %float %401 - %403 = OpFDiv %float %float_1 %402 - OpStore %normalScale %403 - %404 = OpLoad %bool %gl_FrontFacing - OpSelectionMerge %405 None - OpBranchConditional %404 %406 %407 - %406 = OpLabel - %408 = OpLoad %v2float %v_uv - OpStore %x_299 %408 - OpBranch %405 - %407 = OpLabel - %409 = OpLoad %v2float %v_uv - %410 = OpFNegate %v2float %409 - OpStore %x_299 %410 - OpBranch %405 - %405 = OpLabel - %411 = OpLoad %v2float %x_299 - OpStore %TBNUV %411 - %412 = OpLoad %v4float %v_output2 - %413 = OpLoad %float %normalScale - %414 = OpCompositeExtract %float %412 0 - %415 = OpCompositeExtract %float %412 1 - %416 = OpCompositeExtract %float %412 2 - %417 = OpCompositeConstruct %v3float %414 %415 %416 - %418 = OpVectorTimesScalar %v3float %417 %413 - OpStore %param_3 %418 - %419 = OpLoad %v4float %v_output1 - %420 = OpCompositeExtract %float %419 0 - %421 = OpCompositeExtract %float %419 1 - %422 = OpCompositeExtract %float %419 2 - %423 = OpCompositeConstruct %v3float %420 %421 %422 - OpStore %param_4 %423 - %424 = OpLoad %v2float %TBNUV - OpStore %param_5 %424 - %427 = OpAccessChain %_ptr_Uniform_v2float %x_269 %uint_8 - %428 = OpLoad %v2float %427 - OpStore %param_6 %428 - %429 = OpFunctionCall %mat3v3float %cotangent_frame_vf3_vf3_vf2_vf2_ %param_3 %param_4 %param_5 %param_6 - OpStore %TBN %429 - %434 = OpLoad %mat3v3float %TBN - OpStore %param_7 %434 - %435 = OpFunctionCall %mat3v3float %transposeMat3_mf33_ %param_7 - OpStore %invTBN %435 + OpStore %u_Color %369 + %370 = OpLoad %v2float %vMainuv + %372 = OpLoad %28 %TextureSamplerSampler + %373 = OpLoad %25 %TextureSamplerTexture + %375 = OpSampledImage %374 %373 %372 + %371 = OpImageSampleImplicitLod %v4float %375 %370 + OpStore %tempTextureRead %371 + %376 = OpLoad %v4float %tempTextureRead + %379 = OpAccessChain %_ptr_Uniform_float %x_269 %uint_6 + %380 = OpLoad %float %379 + %381 = OpCompositeExtract %float %376 0 + %382 = OpCompositeExtract %float %376 1 + %383 = OpCompositeExtract %float %376 2 + %384 = OpCompositeConstruct %v3float %381 %382 %383 + %385 = OpVectorTimesScalar %v3float %384 %380 + OpStore %rgb %385 + %388 = OpAccessChain %_ptr_Uniform_v3float %x_269 %uint_4 + %389 = OpLoad %v3float %388 + %390 = OpLoad %v4float %v_output1 + %392 = OpCompositeExtract %float %390 0 + %393 = OpCompositeExtract %float %390 1 + %394 = OpCompositeExtract %float %390 2 + %395 = OpCompositeConstruct %v3float %392 %393 %394 + %396 = OpFSub %v3float %389 %395 + %391 = OpExtInst %v3float %88 Normalize %396 + OpStore %output5 %391 + OpStore %output4 %15 + OpStore %uvOffset %31 + %397 = OpAccessChain %_ptr_Uniform_float %x_269 %uint_2 + %398 = OpLoad %float %397 + %399 = OpFDiv %float %float_1 %398 + OpStore %normalScale %399 + %400 = OpLoad %bool %gl_FrontFacing + OpSelectionMerge %401 None + OpBranchConditional %400 %402 %403 + %402 = OpLabel + %404 = OpLoad %v2float %v_uv + OpStore %x_299 %404 + OpBranch %401 + %403 = OpLabel + %405 = OpLoad %v2float %v_uv + %406 = OpFNegate %v2float %405 + OpStore %x_299 %406 + OpBranch %401 + %401 = OpLabel + %407 = OpLoad %v2float %x_299 + OpStore %TBNUV %407 + %408 = OpLoad %v4float %v_output2 + %409 = OpLoad %float %normalScale + %410 = OpCompositeExtract %float %408 0 + %411 = OpCompositeExtract %float %408 1 + %412 = OpCompositeExtract %float %408 2 + %413 = OpCompositeConstruct %v3float %410 %411 %412 + %414 = OpVectorTimesScalar %v3float %413 %409 + OpStore %param_3 %414 + %415 = OpLoad %v4float %v_output1 + %416 = OpCompositeExtract %float %415 0 + %417 = OpCompositeExtract %float %415 1 + %418 = OpCompositeExtract %float %415 2 + %419 = OpCompositeConstruct %v3float %416 %417 %418 + OpStore %param_4 %419 + %420 = OpLoad %v2float %TBNUV + OpStore %param_5 %420 + %423 = OpAccessChain %_ptr_Uniform_v2float %x_269 %uint_8 + %424 = OpLoad %v2float %423 + OpStore %param_6 %424 + %425 = OpFunctionCall %mat3v3float %cotangent_frame_vf3_vf3_vf2_vf2_ %param_3 %param_4 %param_5 %param_6 + OpStore %TBN %425 + %430 = OpLoad %mat3v3float %TBN + OpStore %param_7 %430 + %431 = OpFunctionCall %mat3v3float %transposeMat3_mf33_ %param_7 + OpStore %invTBN %431 + %433 = OpLoad %mat3v3float %invTBN + %434 = OpLoad %v3float %output5 + %435 = OpFNegate %v3float %434 + %436 = OpMatrixTimesVector %v3float %433 %435 %437 = OpLoad %mat3v3float %invTBN %438 = OpLoad %v3float %output5 - %439 = OpFNegate %v3float %438 - %440 = OpMatrixTimesVector %v3float %437 %439 - %441 = OpLoad %mat3v3float %invTBN - %442 = OpLoad %v3float %output5 - %444 = OpCompositeExtract %float %440 0 - %445 = OpCompositeExtract %float %440 1 - %446 = OpCompositeConstruct %v2float %444 %445 - %443 = OpExtInst %float %88 Length %446 - %447 = OpFNegate %v3float %442 - %448 = OpMatrixTimesVector %v3float %441 %447 - %449 = OpCompositeExtract %float %448 2 - %450 = OpFDiv %float %443 %449 - OpStore %parallaxLimit %450 - %452 = OpAccessChain %_ptr_Uniform_float %x_269 %uint_5 - %453 = OpLoad %float %452 - %454 = OpLoad %float %parallaxLimit - %455 = OpFMul %float %454 %453 - OpStore %parallaxLimit %455 - %456 = OpLoad %mat3v3float %invTBN - %457 = OpLoad %v3float %output5 - %458 = OpFNegate %v3float %457 - %459 = OpMatrixTimesVector %v3float %456 %458 - %461 = OpCompositeExtract %float %459 0 - %462 = OpCompositeExtract %float %459 1 - %463 = OpCompositeConstruct %v2float %461 %462 - %460 = OpExtInst %v2float %88 Normalize %463 - OpStore %vOffsetDir %460 - %464 = OpLoad %v2float %vOffsetDir - %465 = OpLoad %float %parallaxLimit - %466 = OpVectorTimesScalar %v2float %464 %465 - OpStore %vMaxOffset %466 - %467 = OpLoad %mat3v3float %invTBN - %468 = OpLoad %v3float %output5 - %469 = OpLoad %mat3v3float %invTBN - %470 = OpLoad %v4float %v_output2 - %473 = OpFNegate %v3float %468 - %474 = OpMatrixTimesVector %v3float %467 %473 - %475 = OpCompositeExtract %float %470 0 - %476 = OpCompositeExtract %float %470 1 - %477 = OpCompositeExtract %float %470 2 - %478 = OpCompositeConstruct %v3float %475 %476 %477 - %479 = OpMatrixTimesVector %v3float %469 %478 - %472 = OpDot %float %474 %479 - %481 = OpFMul %float %472 %float_n11 - %482 = OpFAdd %float %float_15 %481 - OpStore %numSamples %482 - %483 = OpLoad %float %numSamples - %484 = OpFDiv %float %float_1 %483 - OpStore %stepSize %484 + %440 = OpCompositeExtract %float %436 0 + %441 = OpCompositeExtract %float %436 1 + %442 = OpCompositeConstruct %v2float %440 %441 + %439 = OpExtInst %float %88 Length %442 + %443 = OpFNegate %v3float %438 + %444 = OpMatrixTimesVector %v3float %437 %443 + %445 = OpCompositeExtract %float %444 2 + %446 = OpFDiv %float %439 %445 + OpStore %parallaxLimit %446 + %448 = OpAccessChain %_ptr_Uniform_float %x_269 %uint_5 + %449 = OpLoad %float %448 + %450 = OpLoad %float %parallaxLimit + %451 = OpFMul %float %450 %449 + OpStore %parallaxLimit %451 + %452 = OpLoad %mat3v3float %invTBN + %453 = OpLoad %v3float %output5 + %454 = OpFNegate %v3float %453 + %455 = OpMatrixTimesVector %v3float %452 %454 + %457 = OpCompositeExtract %float %455 0 + %458 = OpCompositeExtract %float %455 1 + %459 = OpCompositeConstruct %v2float %457 %458 + %456 = OpExtInst %v2float %88 Normalize %459 + OpStore %vOffsetDir %456 + %460 = OpLoad %v2float %vOffsetDir + %461 = OpLoad %float %parallaxLimit + %462 = OpVectorTimesScalar %v2float %460 %461 + OpStore %vMaxOffset %462 + %463 = OpLoad %mat3v3float %invTBN + %464 = OpLoad %v3float %output5 + %465 = OpLoad %mat3v3float %invTBN + %466 = OpLoad %v4float %v_output2 + %469 = OpFNegate %v3float %464 + %470 = OpMatrixTimesVector %v3float %463 %469 + %471 = OpCompositeExtract %float %466 0 + %472 = OpCompositeExtract %float %466 1 + %473 = OpCompositeExtract %float %466 2 + %474 = OpCompositeConstruct %v3float %471 %472 %473 + %475 = OpMatrixTimesVector %v3float %465 %474 + %468 = OpDot %float %470 %475 + %477 = OpFMul %float %468 %float_n11 + %478 = OpFAdd %float %float_15 %477 + OpStore %numSamples %478 + %479 = OpLoad %float %numSamples + %480 = OpFDiv %float %float_1 %479 + OpStore %stepSize %480 OpStore %currRayHeight %float_1 - OpStore %vCurrOffset %400 - OpStore %vLastOffset %400 + OpStore %vCurrOffset %31 + OpStore %vLastOffset %31 OpStore %lastSampledHeight %float_1 OpStore %currSampledHeight %float_1 - OpStore %i %int_0 - OpBranch %485 - %485 = OpLabel - OpLoopMerge %486 %487 None + OpStore %i %164 + OpBranch %481 + %481 = OpLabel + OpLoopMerge %482 %483 None + OpBranch %484 + %484 = OpLabel + %485 = OpLoad %int %i + %487 = OpSLessThan %bool %485 %int_15 + OpSelectionMerge %488 None + OpBranchConditional %487 %489 %490 + %489 = OpLabel OpBranch %488 + %490 = OpLabel + OpBranch %482 %488 = OpLabel - %489 = OpLoad %int %i - %491 = OpSLessThan %bool %489 %int_15 - OpSelectionMerge %492 None - OpBranchConditional %491 %493 %494 - %493 = OpLabel - OpBranch %492 - %494 = OpLabel - OpBranch %486 - %492 = OpLabel - %495 = OpLoad %v2float %v_uv - %496 = OpLoad %v2float %vCurrOffset - %498 = OpLoad %28 %TextureSamplerSampler - %499 = OpLoad %25 %TextureSamplerTexture - %500 = OpSampledImage %376 %499 %498 - %501 = OpFAdd %v2float %495 %496 - %497 = OpImageSampleImplicitLod %v4float %500 %501 - %502 = OpCompositeExtract %float %497 3 - OpStore %currSampledHeight %502 - %503 = OpLoad %float %currSampledHeight - %504 = OpLoad %float %currRayHeight - %505 = OpFOrdGreaterThan %bool %503 %504 - OpSelectionMerge %506 None - OpBranchConditional %505 %507 %508 - %507 = OpLabel - %509 = OpLoad %float %currSampledHeight - %510 = OpLoad %float %currRayHeight - %511 = OpFSub %float %509 %510 - OpStore %delta1 %511 - %512 = OpLoad %float %currRayHeight - %513 = OpLoad %float %stepSize - %514 = OpLoad %float %lastSampledHeight - %515 = OpFAdd %float %512 %513 - %516 = OpFSub %float %515 %514 - OpStore %delta2 %516 - %517 = OpLoad %float %delta1 - %518 = OpLoad %float %delta1 - %519 = OpLoad %float %delta2 - %520 = OpFAdd %float %518 %519 - %521 = OpFDiv %float %517 %520 - OpStore %ratio %521 - %522 = OpLoad %float %ratio - %523 = OpLoad %v2float %vLastOffset - %524 = OpLoad %float %ratio - %525 = OpLoad %v2float %vCurrOffset - %526 = OpVectorTimesScalar %v2float %523 %522 - %527 = OpFSub %float %float_1 %524 - %528 = OpVectorTimesScalar %v2float %525 %527 - %529 = OpFAdd %v2float %526 %528 - OpStore %vCurrOffset %529 - OpBranch %486 - %508 = OpLabel + %491 = OpLoad %v2float %v_uv + %492 = OpLoad %v2float %vCurrOffset + %494 = OpLoad %28 %TextureSamplerSampler + %495 = OpLoad %25 %TextureSamplerTexture + %496 = OpSampledImage %374 %495 %494 + %497 = OpFAdd %v2float %491 %492 + %493 = OpImageSampleImplicitLod %v4float %496 %497 + %498 = OpCompositeExtract %float %493 3 + OpStore %currSampledHeight %498 + %499 = OpLoad %float %currSampledHeight + %500 = OpLoad %float %currRayHeight + %501 = OpFOrdGreaterThan %bool %499 %500 + OpSelectionMerge %502 None + OpBranchConditional %501 %503 %504 + %503 = OpLabel + %505 = OpLoad %float %currSampledHeight + %506 = OpLoad %float %currRayHeight + %507 = OpFSub %float %505 %506 + OpStore %delta1 %507 + %508 = OpLoad %float %currRayHeight + %509 = OpLoad %float %stepSize + %510 = OpLoad %float %lastSampledHeight + %511 = OpFAdd %float %508 %509 + %512 = OpFSub %float %511 %510 + OpStore %delta2 %512 + %513 = OpLoad %float %delta1 + %514 = OpLoad %float %delta1 + %515 = OpLoad %float %delta2 + %516 = OpFAdd %float %514 %515 + %517 = OpFDiv %float %513 %516 + OpStore %ratio %517 + %518 = OpLoad %float %ratio + %519 = OpLoad %v2float %vLastOffset + %520 = OpLoad %float %ratio + %521 = OpLoad %v2float %vCurrOffset + %522 = OpVectorTimesScalar %v2float %519 %518 + %523 = OpFSub %float %float_1 %520 + %524 = OpVectorTimesScalar %v2float %521 %523 + %525 = OpFAdd %v2float %522 %524 + OpStore %vCurrOffset %525 + OpBranch %482 + %504 = OpLabel + %526 = OpLoad %float %stepSize + %527 = OpLoad %float %currRayHeight + %528 = OpFSub %float %527 %526 + OpStore %currRayHeight %528 + %529 = OpLoad %v2float %vCurrOffset + OpStore %vLastOffset %529 %530 = OpLoad %float %stepSize - %531 = OpLoad %float %currRayHeight - %532 = OpFSub %float %531 %530 - OpStore %currRayHeight %532 - %533 = OpLoad %v2float %vCurrOffset - OpStore %vLastOffset %533 - %534 = OpLoad %float %stepSize - %535 = OpLoad %v2float %vMaxOffset - %536 = OpLoad %v2float %vCurrOffset - %537 = OpVectorTimesScalar %v2float %535 %534 - %538 = OpFAdd %v2float %536 %537 - OpStore %vCurrOffset %538 - %539 = OpLoad %float %currSampledHeight - OpStore %lastSampledHeight %539 - OpBranch %506 - %506 = OpLabel - OpBranch %487 - %487 = OpLabel - %540 = OpLoad %int %i - %541 = OpIAdd %int %540 %int_1 - OpStore %i %541 - OpBranch %485 - %486 = OpLabel - %542 = OpLoad %v2float %vCurrOffset - OpStore %parallaxOcclusion_0 %542 - %543 = OpLoad %v2float %parallaxOcclusion_0 - OpStore %uvOffset %543 - %544 = OpLoad %v2float %v_uv - %545 = OpLoad %v2float %uvOffset - %547 = OpLoad %28 %TextureSamplerSampler - %548 = OpLoad %25 %TextureSamplerTexture - %549 = OpSampledImage %376 %548 %547 - %550 = OpFAdd %v2float %544 %545 - %546 = OpImageSampleImplicitLod %v4float %549 %550 - %551 = OpAccessChain %_ptr_Uniform_float %x_269 %uint_2 - %552 = OpLoad %float %551 - %553 = OpLoad %mat3v3float %TBN - OpStore %param_8 %553 - %554 = OpCompositeExtract %float %546 0 - %555 = OpCompositeExtract %float %546 1 - %556 = OpCompositeExtract %float %546 2 - %557 = OpCompositeConstruct %v3float %554 %555 %556 - OpStore %param_9 %557 - %558 = OpFDiv %float %float_1 %552 - OpStore %param_10 %558 - %559 = OpFunctionCall %v3float %perturbNormal_mf33_vf3_f1_ %param_8 %param_9 %param_10 - %563 = OpLoad %v4float %output4 - %564 = OpCompositeExtract %float %559 0 - %565 = OpCompositeExtract %float %559 1 - %566 = OpCompositeExtract %float %559 2 - %567 = OpCompositeExtract %float %563 3 - %568 = OpCompositeConstruct %v4float %564 %565 %566 %567 - OpStore %output4 %568 - %569 = OpLoad %v2float %v_uv - %570 = OpLoad %v2float %uvOffset - %571 = OpFAdd %v2float %569 %570 - OpStore %output6 %571 - %572 = OpLoad %v2float %output6 - %574 = OpLoad %28 %TextureSampler1Sampler - %575 = OpLoad %25 %TextureSampler1Texture - %576 = OpSampledImage %376 %575 %574 - %573 = OpImageSampleImplicitLod %v4float %576 %572 - OpStore %tempTextureRead1 %573 - %577 = OpLoad %v4float %tempTextureRead1 - %578 = OpCompositeExtract %float %577 0 - %579 = OpCompositeExtract %float %577 1 - %580 = OpCompositeExtract %float %577 2 - %581 = OpCompositeConstruct %v3float %578 %579 %580 - OpStore %rgb1 %581 - %582 = OpAccessChain %_ptr_Uniform_v3float %x_269 %uint_4 - %583 = OpLoad %v3float %582 - %584 = OpLoad %v4float %v_output1 - %586 = OpCompositeExtract %float %584 0 - %587 = OpCompositeExtract %float %584 1 - %588 = OpCompositeExtract %float %584 2 - %589 = OpCompositeConstruct %v3float %586 %587 %588 - %590 = OpFSub %v3float %583 %589 - %585 = OpExtInst %v3float %88 Normalize %590 - OpStore %viewDirectionW_1 %585 + %531 = OpLoad %v2float %vMaxOffset + %532 = OpLoad %v2float %vCurrOffset + %533 = OpVectorTimesScalar %v2float %531 %530 + %534 = OpFAdd %v2float %532 %533 + OpStore %vCurrOffset %534 + %535 = OpLoad %float %currSampledHeight + OpStore %lastSampledHeight %535 + OpBranch %502 + %502 = OpLabel + OpBranch %483 + %483 = OpLabel + %536 = OpLoad %int %i + %537 = OpIAdd %int %536 %int_1 + OpStore %i %537 + OpBranch %481 + %482 = OpLabel + %538 = OpLoad %v2float %vCurrOffset + OpStore %parallaxOcclusion_0 %538 + %539 = OpLoad %v2float %parallaxOcclusion_0 + OpStore %uvOffset %539 + %540 = OpLoad %v2float %v_uv + %541 = OpLoad %v2float %uvOffset + %543 = OpLoad %28 %TextureSamplerSampler + %544 = OpLoad %25 %TextureSamplerTexture + %545 = OpSampledImage %374 %544 %543 + %546 = OpFAdd %v2float %540 %541 + %542 = OpImageSampleImplicitLod %v4float %545 %546 + %547 = OpAccessChain %_ptr_Uniform_float %x_269 %uint_2 + %548 = OpLoad %float %547 + %549 = OpLoad %mat3v3float %TBN + OpStore %param_8 %549 + %550 = OpCompositeExtract %float %542 0 + %551 = OpCompositeExtract %float %542 1 + %552 = OpCompositeExtract %float %542 2 + %553 = OpCompositeConstruct %v3float %550 %551 %552 + OpStore %param_9 %553 + %554 = OpFDiv %float %float_1 %548 + OpStore %param_10 %554 + %555 = OpFunctionCall %v3float %perturbNormal_mf33_vf3_f1_ %param_8 %param_9 %param_10 + %559 = OpLoad %v4float %output4 + %560 = OpCompositeExtract %float %555 0 + %561 = OpCompositeExtract %float %555 1 + %562 = OpCompositeExtract %float %555 2 + %563 = OpCompositeExtract %float %559 3 + %564 = OpCompositeConstruct %v4float %560 %561 %562 %563 + OpStore %output4 %564 + %565 = OpLoad %v2float %v_uv + %566 = OpLoad %v2float %uvOffset + %567 = OpFAdd %v2float %565 %566 + OpStore %output6 %567 + %568 = OpLoad %v2float %output6 + %570 = OpLoad %28 %TextureSampler1Sampler + %571 = OpLoad %25 %TextureSampler1Texture + %572 = OpSampledImage %374 %571 %570 + %569 = OpImageSampleImplicitLod %v4float %572 %568 + OpStore %tempTextureRead1 %569 + %573 = OpLoad %v4float %tempTextureRead1 + %574 = OpCompositeExtract %float %573 0 + %575 = OpCompositeExtract %float %573 1 + %576 = OpCompositeExtract %float %573 2 + %577 = OpCompositeConstruct %v3float %574 %575 %576 + OpStore %rgb1 %577 + %578 = OpAccessChain %_ptr_Uniform_v3float %x_269 %uint_4 + %579 = OpLoad %v3float %578 + %580 = OpLoad %v4float %v_output1 + %582 = OpCompositeExtract %float %580 0 + %583 = OpCompositeExtract %float %580 1 + %584 = OpCompositeExtract %float %580 2 + %585 = OpCompositeConstruct %v3float %582 %583 %584 + %586 = OpFSub %v3float %579 %585 + %581 = OpExtInst %v3float %88 Normalize %586 + OpStore %viewDirectionW_1 %581 OpStore %shadow %float_1 - %591 = OpLoad %float %u_Float - %592 = OpFMul %float %float_1 %591 - OpStore %glossiness_1 %592 - OpStore %diffuseBase %593 - OpStore %specularBase %593 - %594 = OpLoad %v4float %output4 - %595 = OpCompositeExtract %float %594 0 - %596 = OpCompositeExtract %float %594 1 - %597 = OpCompositeExtract %float %594 2 - %598 = OpCompositeConstruct %v3float %595 %596 %597 - OpStore %normalW %598 - %599 = OpLoad %v3float %viewDirectionW_1 - OpStore %param_11 %599 - %600 = OpLoad %v3float %normalW - OpStore %param_12 %600 - %602 = OpAccessChain %_ptr_Uniform_v4float %light0 %uint_0 - %603 = OpLoad %v4float %602 - OpStore %param_13 %603 - %604 = OpAccessChain %_ptr_Uniform_v4float %light0 %uint_1 - %605 = OpLoad %v4float %604 - %606 = OpCompositeExtract %float %605 0 - %607 = OpCompositeExtract %float %605 1 - %608 = OpCompositeExtract %float %605 2 - %609 = OpCompositeConstruct %v3float %606 %607 %608 - OpStore %param_14 %609 - %610 = OpAccessChain %_ptr_Uniform_v4float %light0 %uint_2 - %611 = OpLoad %v4float %610 - %612 = OpCompositeExtract %float %611 0 - %613 = OpCompositeExtract %float %611 1 - %614 = OpCompositeExtract %float %611 2 - %615 = OpCompositeConstruct %v3float %612 %613 %614 - OpStore %param_15 %615 - %617 = OpAccessChain %_ptr_Uniform_v3float %light0 %uint_3 - %618 = OpLoad %v3float %617 - OpStore %param_16 %618 - %619 = OpLoad %float %glossiness_1 - OpStore %param_17 %619 - %620 = OpFunctionCall %lightingInfo %computeHemisphericLighting_vf3_vf3_vf4_vf3_vf3_vf3_f1_ %param_11 %param_12 %param_13 %param_14 %param_15 %param_16 %param_17 - OpStore %info %620 + %587 = OpLoad %float %u_Float + %588 = OpFMul %float %float_1 %587 + OpStore %glossiness_1 %588 + OpStore %diffuseBase %22 + OpStore %specularBase %22 + %589 = OpLoad %v4float %output4 + %590 = OpCompositeExtract %float %589 0 + %591 = OpCompositeExtract %float %589 1 + %592 = OpCompositeExtract %float %589 2 + %593 = OpCompositeConstruct %v3float %590 %591 %592 + OpStore %normalW %593 + %594 = OpLoad %v3float %viewDirectionW_1 + OpStore %param_11 %594 + %595 = OpLoad %v3float %normalW + OpStore %param_12 %595 + %597 = OpAccessChain %_ptr_Uniform_v4float %light0 %uint_0 + %598 = OpLoad %v4float %597 + OpStore %param_13 %598 + %599 = OpAccessChain %_ptr_Uniform_v4float %light0 %uint_1 + %600 = OpLoad %v4float %599 + %601 = OpCompositeExtract %float %600 0 + %602 = OpCompositeExtract %float %600 1 + %603 = OpCompositeExtract %float %600 2 + %604 = OpCompositeConstruct %v3float %601 %602 %603 + OpStore %param_14 %604 + %605 = OpAccessChain %_ptr_Uniform_v4float %light0 %uint_2 + %606 = OpLoad %v4float %605 + %607 = OpCompositeExtract %float %606 0 + %608 = OpCompositeExtract %float %606 1 + %609 = OpCompositeExtract %float %606 2 + %610 = OpCompositeConstruct %v3float %607 %608 %609 + OpStore %param_15 %610 + %612 = OpAccessChain %_ptr_Uniform_v3float %light0 %uint_3 + %613 = OpLoad %v3float %612 + OpStore %param_16 %613 + %614 = OpLoad %float %glossiness_1 + OpStore %param_17 %614 + %615 = OpFunctionCall %lightingInfo %computeHemisphericLighting_vf3_vf3_vf4_vf3_vf3_vf3_f1_ %param_11 %param_12 %param_13 %param_14 %param_15 %param_16 %param_17 + OpStore %info %615 OpStore %shadow %float_1 - %628 = OpAccessChain %_ptr_Function_v3float %info %uint_0 - %629 = OpLoad %v3float %628 - %630 = OpLoad %float %shadow - %631 = OpLoad %v3float %diffuseBase - %632 = OpVectorTimesScalar %v3float %629 %630 - %633 = OpFAdd %v3float %631 %632 - OpStore %diffuseBase %633 - %634 = OpAccessChain %_ptr_Function_v3float %info %uint_1 - %635 = OpLoad %v3float %634 - %636 = OpLoad %float %shadow - %637 = OpLoad %v3float %specularBase - %638 = OpVectorTimesScalar %v3float %635 %636 - %639 = OpFAdd %v3float %637 %638 - OpStore %specularBase %639 - %640 = OpLoad %v3float %diffuseBase - %641 = OpLoad %v3float %rgb1 - %642 = OpFMul %v3float %640 %641 - OpStore %diffuseOutput %642 - %643 = OpLoad %v3float %specularBase - %644 = OpLoad %v3float %u_Color - %645 = OpFMul %v3float %643 %644 - OpStore %specularOutput %645 - %646 = OpLoad %v3float %diffuseOutput - %647 = OpLoad %v3float %specularOutput - %648 = OpFAdd %v3float %646 %647 - OpStore %output3 %648 - %649 = OpLoad %v3float %output3 - %650 = OpCompositeExtract %float %649 0 - %651 = OpCompositeExtract %float %649 1 - %652 = OpCompositeExtract %float %649 2 - %653 = OpCompositeConstruct %v4float %650 %651 %652 %float_1 - OpStore %glFragColor %653 + %623 = OpAccessChain %_ptr_Function_v3float %info %uint_0 + %624 = OpLoad %v3float %623 + %625 = OpLoad %float %shadow + %626 = OpLoad %v3float %diffuseBase + %627 = OpVectorTimesScalar %v3float %624 %625 + %628 = OpFAdd %v3float %626 %627 + OpStore %diffuseBase %628 + %629 = OpAccessChain %_ptr_Function_v3float %info %uint_1 + %630 = OpLoad %v3float %629 + %631 = OpLoad %float %shadow + %632 = OpLoad %v3float %specularBase + %633 = OpVectorTimesScalar %v3float %630 %631 + %634 = OpFAdd %v3float %632 %633 + OpStore %specularBase %634 + %635 = OpLoad %v3float %diffuseBase + %636 = OpLoad %v3float %rgb1 + %637 = OpFMul %v3float %635 %636 + OpStore %diffuseOutput %637 + %638 = OpLoad %v3float %specularBase + %639 = OpLoad %v3float %u_Color + %640 = OpFMul %v3float %638 %639 + OpStore %specularOutput %640 + %641 = OpLoad %v3float %diffuseOutput + %642 = OpLoad %v3float %specularOutput + %643 = OpFAdd %v3float %641 %642 + OpStore %output3 %643 + %644 = OpLoad %v3float %output3 + %645 = OpCompositeExtract %float %644 0 + %646 = OpCompositeExtract %float %644 1 + %647 = OpCompositeExtract %float %644 2 + %648 = OpCompositeConstruct %v4float %645 %646 %647 %float_1 + OpStore %glFragColor %648 OpReturn OpFunctionEnd - %main_inner = OpFunction %main_out None %654 + %main_inner = OpFunction %main_out None %649 %vMainuv_param = OpFunctionParameter %v2float %v_output1_param = OpFunctionParameter %v4float %gl_FrontFacing_param = OpFunctionParameter %bool %v_uv_param = OpFunctionParameter %v2float %v_output2_param = OpFunctionParameter %v4float - %662 = OpLabel + %657 = OpLabel OpStore %vMainuv %vMainuv_param OpStore %v_output1 %v_output1_param OpStore %gl_FrontFacing %gl_FrontFacing_param OpStore %v_uv %v_uv_param OpStore %v_output2 %v_output2_param - %663 = OpFunctionCall %void %main_1 - %664 = OpLoad %v4float %glFragColor - %665 = OpCompositeConstruct %main_out %664 - OpReturnValue %665 + %658 = OpFunctionCall %void %main_1 + %659 = OpLoad %v4float %glFragColor + %660 = OpCompositeConstruct %main_out %659 + OpReturnValue %660 OpFunctionEnd - %main = OpFunction %void None %311 - %667 = OpLabel - %669 = OpLoad %v2float %vMainuv_param_1 - %670 = OpLoad %v4float %v_output1_param_1 - %671 = OpLoad %bool %gl_FrontFacing_param_1 - %672 = OpLoad %v2float %v_uv_param_1 - %673 = OpLoad %v4float %v_output2_param_1 - %668 = OpFunctionCall %main_out %main_inner %669 %670 %671 %672 %673 - %674 = OpCompositeExtract %v4float %668 0 - OpStore %glFragColor_1_1 %674 + %main = OpFunction %void None %310 + %662 = OpLabel + %664 = OpLoad %v2float %vMainuv_param_1 + %665 = OpLoad %v4float %v_output1_param_1 + %666 = OpLoad %bool %gl_FrontFacing_param_1 + %667 = OpLoad %v2float %v_uv_param_1 + %668 = OpLoad %v4float %v_output2_param_1 + %663 = OpFunctionCall %main_out %main_inner %664 %665 %666 %667 %668 + %669 = OpCompositeExtract %v4float %663 0 + OpStore %glFragColor_1_1 %669 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/951.spvasm.expected.spvasm b/test/tint/bug/tint/951.spvasm.expected.spvasm index dfbd8ded3d..9bd8675500 100644 --- a/test/tint/bug/tint/951.spvasm.expected.spvasm +++ b/test/tint/bug/tint/951.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 97 +; Bound: 96 ; Schema: 0 OpCapability Shader %46 = OpExtInstImport "GLSL.std.450" @@ -83,7 +83,7 @@ %_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float %_ptr_Function_float = OpTypePointer Function %float %30 = OpTypeFunction %float %_ptr_Function_float - %float_0 = OpConstant %float 0 + %37 = OpConstantNull %float %bool = OpTypeBool %float_0x1p_128 = OpConstant %float 0x1p+128 %void = OpTypeVoid @@ -91,10 +91,9 @@ %47 = OpTypeFunction %void %_ptr_Function_int %_ptr_Function_float %59 = OpTypeFunction %void %63 = OpConstantNull %int - %65 = OpConstantNull %float %uint_4 = OpConstant %uint 4 %_ptr_Uniform_int = OpTypePointer Uniform %int - %88 = OpTypeFunction %void %v3uint + %87 = OpTypeFunction %void %v3uint %getAAtOutCoords_ = OpFunction %float None %20 %22 = OpLabel %25 = OpAccessChain %_ptr_Private_uint %gl_GlobalInvocationID %uint_0 @@ -107,7 +106,7 @@ %a = OpFunctionParameter %_ptr_Function_float %34 = OpLabel %36 = OpLoad %float %a - %38 = OpFOrdLessThan %bool %36 %float_0 + %38 = OpFOrdLessThan %bool %36 %37 OpSelectionMerge %40 None OpBranchConditional %38 %41 %40 %41 = OpLabel @@ -130,44 +129,44 @@ %main_1 = OpFunction %void None %59 %61 = OpLabel %index = OpVariable %_ptr_Function_int Function %63 - %a_1 = OpVariable %_ptr_Function_float Function %65 - %param = OpVariable %_ptr_Function_float Function %65 + %a_1 = OpVariable %_ptr_Function_float Function %37 + %param = OpVariable %_ptr_Function_float Function %37 %param_1 = OpVariable %_ptr_Function_int Function %63 - %param_2 = OpVariable %_ptr_Function_float Function %65 - %69 = OpAccessChain %_ptr_Private_uint %gl_GlobalInvocationID %uint_0 - %70 = OpLoad %uint %69 - %71 = OpBitcast %int %70 - OpStore %index %71 - %72 = OpLoad %int %index - %75 = OpAccessChain %_ptr_Uniform_int %x_24 %uint_4 - %76 = OpLoad %int %75 - %77 = OpSLessThan %bool %72 %76 - OpSelectionMerge %78 None - OpBranchConditional %77 %79 %78 - %79 = OpLabel - %80 = OpFunctionCall %float %getAAtOutCoords_ - OpStore %a_1 %80 - %81 = OpLoad %float %a_1 - OpStore %param %81 - %82 = OpFunctionCall %float %unaryOperation_f1_ %param - %84 = OpLoad %int %index - OpStore %param_1 %84 - OpStore %param_2 %82 - %85 = OpFunctionCall %void %setOutput_i1_f1_ %param_1 %param_2 - OpBranch %78 + %param_2 = OpVariable %_ptr_Function_float Function %37 + %68 = OpAccessChain %_ptr_Private_uint %gl_GlobalInvocationID %uint_0 + %69 = OpLoad %uint %68 + %70 = OpBitcast %int %69 + OpStore %index %70 + %71 = OpLoad %int %index + %74 = OpAccessChain %_ptr_Uniform_int %x_24 %uint_4 + %75 = OpLoad %int %74 + %76 = OpSLessThan %bool %71 %75 + OpSelectionMerge %77 None + OpBranchConditional %76 %78 %77 %78 = OpLabel + %79 = OpFunctionCall %float %getAAtOutCoords_ + OpStore %a_1 %79 + %80 = OpLoad %float %a_1 + OpStore %param %80 + %81 = OpFunctionCall %float %unaryOperation_f1_ %param + %83 = OpLoad %int %index + OpStore %param_1 %83 + OpStore %param_2 %81 + %84 = OpFunctionCall %void %setOutput_i1_f1_ %param_1 %param_2 + OpBranch %77 + %77 = OpLabel OpReturn OpFunctionEnd - %main_inner = OpFunction %void None %88 + %main_inner = OpFunction %void None %87 %gl_GlobalInvocationID_param = OpFunctionParameter %v3uint - %91 = OpLabel + %90 = OpLabel OpStore %gl_GlobalInvocationID %gl_GlobalInvocationID_param - %92 = OpFunctionCall %void %main_1 + %91 = OpFunctionCall %void %main_1 OpReturn OpFunctionEnd %main = OpFunction %void None %59 - %94 = OpLabel - %96 = OpLoad %v3uint %gl_GlobalInvocationID_param_1 - %95 = OpFunctionCall %void %main_inner %96 + %93 = OpLabel + %95 = OpLoad %v3uint %gl_GlobalInvocationID_param_1 + %94 = OpFunctionCall %void %main_inner %95 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/977.spvasm.expected.spvasm b/test/tint/bug/tint/977.spvasm.expected.spvasm index 46407251ed..fa88dfede5 100644 --- a/test/tint/bug/tint/977.spvasm.expected.spvasm +++ b/test/tint/bug/tint/977.spvasm.expected.spvasm @@ -1,10 +1,10 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 103 +; Bound: 102 ; Schema: 0 OpCapability Shader - %43 = OpExtInstImport "GLSL.std.450" + %42 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID_param_1 OpExecutionMode %main LocalSize 1 1 1 @@ -84,93 +84,92 @@ %_ptr_Function_float = OpTypePointer Function %float %23 = OpTypeFunction %float %_ptr_Function_float %_ptr_Function_float %30 = OpConstantNull %float - %float_0 = OpConstant %float 0 %bool = OpTypeBool %float_1 = OpConstant %float 1 %float_2 = OpConstant %float 2 %void = OpTypeVoid - %70 = OpTypeFunction %void + %69 = OpTypeFunction %void %_ptr_Function_int = OpTypePointer Function %int - %76 = OpConstantNull %int + %75 = OpConstantNull %int %uint_0 = OpConstant %uint 0 %_ptr_Private_uint = OpTypePointer Private %uint %int_n10 = OpConstant %int -10 %float_n4 = OpConstant %float -4 %float_n3 = OpConstant %float -3 %_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float - %94 = OpTypeFunction %void %v3uint + %93 = OpTypeFunction %void %v3uint %binaryOperation_f1_f1_ = OpFunction %float None %23 %a = OpFunctionParameter %_ptr_Function_float %b = OpFunctionParameter %_ptr_Function_float %28 = OpLabel %x_26 = OpVariable %_ptr_Function_float Function %30 %32 = OpLoad %float %b - %34 = OpFOrdEqual %bool %32 %float_0 - OpSelectionMerge %36 None - OpBranchConditional %34 %37 %36 - %37 = OpLabel - OpReturnValue %float_1 + %33 = OpFOrdEqual %bool %32 %30 + OpSelectionMerge %35 None + OpBranchConditional %33 %36 %35 %36 = OpLabel - %40 = OpLoad %float %b - %46 = OpFDiv %float %40 %float_2 - %45 = OpExtInst %float %43 Floor %46 - %47 = OpFMul %float %float_2 %45 - %48 = OpFSub %float %40 %47 - %42 = OpExtInst %float %43 RoundEven %48 - %49 = OpFOrdEqual %bool %42 %float_1 - %41 = OpLogicalNot %bool %49 - OpSelectionMerge %50 None - OpBranchConditional %41 %51 %52 - %51 = OpLabel - %54 = OpLoad %float %a - %56 = OpLoad %float %b - %58 = OpExtInst %float %43 FAbs %54 - %57 = OpExtInst %float %43 Pow %58 %56 - OpStore %x_26 %57 - OpBranch %50 - %52 = OpLabel - %60 = OpLoad %float %a - %62 = OpLoad %float %a - %64 = OpLoad %float %b - %65 = OpExtInst %float %43 FSign %60 - %67 = OpExtInst %float %43 FAbs %62 - %66 = OpExtInst %float %43 Pow %67 %64 - %68 = OpFMul %float %65 %66 - OpStore %x_26 %68 - OpBranch %50 + OpReturnValue %float_1 + %35 = OpLabel + %39 = OpLoad %float %b + %45 = OpFDiv %float %39 %float_2 + %44 = OpExtInst %float %42 Floor %45 + %46 = OpFMul %float %float_2 %44 + %47 = OpFSub %float %39 %46 + %41 = OpExtInst %float %42 RoundEven %47 + %48 = OpFOrdEqual %bool %41 %float_1 + %40 = OpLogicalNot %bool %48 + OpSelectionMerge %49 None + OpBranchConditional %40 %50 %51 %50 = OpLabel - %69 = OpLoad %float %x_26 - OpReturnValue %69 + %53 = OpLoad %float %a + %55 = OpLoad %float %b + %57 = OpExtInst %float %42 FAbs %53 + %56 = OpExtInst %float %42 Pow %57 %55 + OpStore %x_26 %56 + OpBranch %49 + %51 = OpLabel + %59 = OpLoad %float %a + %61 = OpLoad %float %a + %63 = OpLoad %float %b + %64 = OpExtInst %float %42 FSign %59 + %66 = OpExtInst %float %42 FAbs %61 + %65 = OpExtInst %float %42 Pow %66 %63 + %67 = OpFMul %float %64 %65 + OpStore %x_26 %67 + OpBranch %49 + %49 = OpLabel + %68 = OpLoad %float %x_26 + OpReturnValue %68 OpFunctionEnd - %main_1 = OpFunction %void None %70 - %73 = OpLabel - %index = OpVariable %_ptr_Function_int Function %76 - %a_1 = OpVariable %_ptr_Function_int Function %76 + %main_1 = OpFunction %void None %69 + %72 = OpLabel + %index = OpVariable %_ptr_Function_int Function %75 + %a_1 = OpVariable %_ptr_Function_int Function %75 %param = OpVariable %_ptr_Function_float Function %30 %param_1 = OpVariable %_ptr_Function_float Function %30 - %82 = OpAccessChain %_ptr_Private_uint %gl_GlobalInvocationID %uint_0 - %83 = OpLoad %uint %82 - %84 = OpBitcast %int %83 - OpStore %index %84 + %81 = OpAccessChain %_ptr_Private_uint %gl_GlobalInvocationID %uint_0 + %82 = OpLoad %uint %81 + %83 = OpBitcast %int %82 + OpStore %index %83 OpStore %a_1 %int_n10 - %86 = OpLoad %int %index + %85 = OpLoad %int %index OpStore %param %float_n4 OpStore %param_1 %float_n3 - %89 = OpFunctionCall %float %binaryOperation_f1_f1_ %param %param_1 - %93 = OpAccessChain %_ptr_StorageBuffer_float %resultMatrix %uint_0 %86 - OpStore %93 %89 + %88 = OpFunctionCall %float %binaryOperation_f1_f1_ %param %param_1 + %92 = OpAccessChain %_ptr_StorageBuffer_float %resultMatrix %uint_0 %85 + OpStore %92 %88 OpReturn OpFunctionEnd - %main_inner = OpFunction %void None %94 + %main_inner = OpFunction %void None %93 %gl_GlobalInvocationID_param = OpFunctionParameter %v3uint - %97 = OpLabel + %96 = OpLabel OpStore %gl_GlobalInvocationID %gl_GlobalInvocationID_param - %98 = OpFunctionCall %void %main_1 + %97 = OpFunctionCall %void %main_1 OpReturn OpFunctionEnd - %main = OpFunction %void None %70 - %100 = OpLabel - %102 = OpLoad %v3uint %gl_GlobalInvocationID_param_1 - %101 = OpFunctionCall %void %main_inner %102 + %main = OpFunction %void None %69 + %99 = OpLabel + %101 = OpLoad %v3uint %gl_GlobalInvocationID_param_1 + %100 = OpFunctionCall %void %main_inner %101 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/980.wgsl.expected.spvasm b/test/tint/bug/tint/980.wgsl.expected.spvasm index b3534571fd..8eb0c28adf 100644 --- a/test/tint/bug/tint/980.wgsl.expected.spvasm +++ b/test/tint/bug/tint/980.wgsl.expected.spvasm @@ -1,10 +1,10 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 47 +; Bound: 45 ; Schema: 0 OpCapability Shader - %23 = OpExtInstImport "GLSL.std.450" + %21 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %main "main" %idx_1 OpExecutionMode %main LocalSize 1 1 1 @@ -35,48 +35,46 @@ %_ptr_StorageBuffer_S = OpTypePointer StorageBuffer %S %io = OpVariable %_ptr_StorageBuffer_S StorageBuffer %9 = OpTypeFunction %v3float %uint %v3float - %float_0 = OpConstant %float 0 - %15 = OpConstantComposite %v3float %float_0 %float_0 %float_0 + %14 = OpConstantNull %v3float %_ptr_Function_v3float = OpTypePointer Function %v3float - %18 = OpConstantNull %v3float %_ptr_Function_float = OpTypePointer Function %float %void = OpTypeVoid - %27 = OpTypeFunction %void %uint + %25 = OpTypeFunction %void %uint %uint_1 = OpConstant %uint 1 %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint %uint_0 = OpConstant %uint 0 %_ptr_StorageBuffer_v3float = OpTypePointer StorageBuffer %v3float - %42 = OpTypeFunction %void + %40 = OpTypeFunction %void %Bad = OpFunction %v3float None %9 %index = OpFunctionParameter %uint %rd = OpFunctionParameter %v3float %13 = OpLabel - %normal = OpVariable %_ptr_Function_v3float Function %18 - OpStore %normal %15 - %20 = OpAccessChain %_ptr_Function_float %normal %index - %24 = OpVectorExtractDynamic %float %rd %index - %22 = OpExtInst %float %23 FSign %24 - %21 = OpFNegate %float %22 - OpStore %20 %21 - %26 = OpLoad %v3float %normal - %25 = OpExtInst %v3float %23 Normalize %26 - OpReturnValue %25 + %normal = OpVariable %_ptr_Function_v3float Function %14 + OpStore %normal %14 + %18 = OpAccessChain %_ptr_Function_float %normal %index + %22 = OpVectorExtractDynamic %float %rd %index + %20 = OpExtInst %float %21 FSign %22 + %19 = OpFNegate %float %20 + OpStore %18 %19 + %24 = OpLoad %v3float %normal + %23 = OpExtInst %v3float %21 Normalize %24 + OpReturnValue %23 OpFunctionEnd - %main_inner = OpFunction %void None %27 + %main_inner = OpFunction %void None %25 %idx = OpFunctionParameter %uint - %31 = OpLabel - %35 = OpAccessChain %_ptr_StorageBuffer_uint %io %uint_1 - %36 = OpLoad %uint %35 + %29 = OpLabel + %33 = OpAccessChain %_ptr_StorageBuffer_uint %io %uint_1 + %34 = OpLoad %uint %33 + %37 = OpAccessChain %_ptr_StorageBuffer_v3float %io %uint_0 + %38 = OpLoad %v3float %37 + %30 = OpFunctionCall %v3float %Bad %34 %38 %39 = OpAccessChain %_ptr_StorageBuffer_v3float %io %uint_0 - %40 = OpLoad %v3float %39 - %32 = OpFunctionCall %v3float %Bad %36 %40 - %41 = OpAccessChain %_ptr_StorageBuffer_v3float %io %uint_0 - OpStore %41 %32 + OpStore %39 %30 OpReturn OpFunctionEnd - %main = OpFunction %void None %42 - %44 = OpLabel - %46 = OpLoad %uint %idx_1 - %45 = OpFunctionCall %void %main_inner %46 + %main = OpFunction %void None %40 + %42 = OpLabel + %44 = OpLoad %uint %idx_1 + %43 = OpFunctionCall %void %main_inner %44 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/990.wgsl.expected.spvasm b/test/tint/bug/tint/990.wgsl.expected.spvasm index 90b0f54117..bea62e1879 100644 --- a/test/tint/bug/tint/990.wgsl.expected.spvasm +++ b/test/tint/bug/tint/990.wgsl.expected.spvasm @@ -16,7 +16,7 @@ %_ptr_Function_int = OpTypePointer Function %int %10 = OpConstantNull %int %bool = OpTypeBool - %false = OpConstantFalse %bool + %17 = OpConstantNull %bool %unused_entry_point = OpFunction %void None %1 %4 = OpLabel OpReturn @@ -29,7 +29,7 @@ OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel - %15 = OpLogicalNot %bool %false + %15 = OpLogicalNot %bool %17 OpSelectionMerge %18 None OpBranchConditional %15 %19 %18 %19 = OpLabel diff --git a/test/tint/bug/tint/992.wgsl.expected.spvasm b/test/tint/bug/tint/992.wgsl.expected.spvasm index e077344ddb..721b89d7e0 100644 --- a/test/tint/bug/tint/992.wgsl.expected.spvasm +++ b/test/tint/bug/tint/992.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 30 +; Bound: 29 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -19,33 +19,32 @@ %5 = OpConstantNull %v4float %value = OpVariable %_ptr_Output_v4float Output %5 %6 = OpTypeFunction %v4float - %float_0 = OpConstant %float 0 + %9 = OpConstantNull %float %_ptr_Function_float = OpTypePointer Function %float - %12 = OpConstantNull %float %v3float = OpTypeVector %float 3 %_ptr_Function_v3float = OpTypePointer Function %v3float - %18 = OpConstantNull %v3float + %17 = OpConstantNull %v3float %float_1 = OpConstant %float 1 %void = OpTypeVoid - %25 = OpTypeFunction %void + %24 = OpTypeFunction %void %frag_main_inner = OpFunction %v4float None %6 %8 = OpLabel - %b = OpVariable %_ptr_Function_float Function %12 - %v = OpVariable %_ptr_Function_v3float Function %18 - OpStore %b %float_0 - %14 = OpLoad %float %b - %15 = OpCompositeConstruct %v3float %14 %14 %14 - OpStore %v %15 - %19 = OpLoad %v3float %v - %20 = OpCompositeExtract %float %19 0 - %21 = OpCompositeExtract %float %19 1 - %22 = OpCompositeExtract %float %19 2 - %24 = OpCompositeConstruct %v4float %20 %21 %22 %float_1 - OpReturnValue %24 + %b = OpVariable %_ptr_Function_float Function %9 + %v = OpVariable %_ptr_Function_v3float Function %17 + OpStore %b %9 + %13 = OpLoad %float %b + %14 = OpCompositeConstruct %v3float %13 %13 %13 + OpStore %v %14 + %18 = OpLoad %v3float %v + %19 = OpCompositeExtract %float %18 0 + %20 = OpCompositeExtract %float %18 1 + %21 = OpCompositeExtract %float %18 2 + %23 = OpCompositeConstruct %v4float %19 %20 %21 %float_1 + OpReturnValue %23 OpFunctionEnd - %frag_main = OpFunction %void None %25 - %28 = OpLabel - %29 = OpFunctionCall %v4float %frag_main_inner - OpStore %value %29 + %frag_main = OpFunction %void None %24 + %27 = OpLabel + %28 = OpFunctionCall %v4float %frag_main_inner + OpStore %value %28 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/993.wgsl.expected.spvasm b/test/tint/bug/tint/993.wgsl.expected.spvasm index 25bf0b536b..07e03b21fc 100644 --- a/test/tint/bug/tint/993.wgsl.expected.spvasm +++ b/test/tint/bug/tint/993.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 36 +; Bound: 37 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -49,25 +49,26 @@ %14 = OpTypeFunction %int %uint_1 = OpConstant %uint 1 %uint_0 = OpConstant %uint 0 + %21 = OpConstantNull %uint %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_StorageBuffer_int = OpTypePointer StorageBuffer %int %void = OpTypeVoid - %28 = OpTypeFunction %void + %29 = OpTypeFunction %void %_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint %runTest = OpFunction %int None %14 %16 = OpLabel - %23 = OpAccessChain %_ptr_Uniform_uint %constants %uint_0 - %24 = OpLoad %uint %23 - %25 = OpIAdd %uint %uint_0 %24 - %27 = OpAccessChain %_ptr_StorageBuffer_int %s %uint_0 %25 - %17 = OpAtomicLoad %int %27 %uint_1 %uint_0 + %24 = OpAccessChain %_ptr_Uniform_uint %constants %uint_0 + %25 = OpLoad %uint %24 + %26 = OpIAdd %uint %21 %25 + %28 = OpAccessChain %_ptr_StorageBuffer_int %s %uint_0 %26 + %17 = OpAtomicLoad %int %28 %uint_1 %uint_0 OpReturnValue %17 OpFunctionEnd - %main = OpFunction %void None %28 - %31 = OpLabel - %32 = OpFunctionCall %int %runTest - %33 = OpBitcast %uint %32 - %35 = OpAccessChain %_ptr_StorageBuffer_uint %result %uint_0 - OpStore %35 %33 + %main = OpFunction %void None %29 + %32 = OpLabel + %33 = OpFunctionCall %int %runTest + %34 = OpBitcast %uint %33 + %36 = OpAccessChain %_ptr_StorageBuffer_uint %result %uint_0 + OpStore %36 %34 OpReturn OpFunctionEnd diff --git a/test/tint/bug/tint/998.wgsl.expected.spvasm b/test/tint/bug/tint/998.wgsl.expected.spvasm index 36525c0b69..8d3cc7422a 100644 --- a/test/tint/bug/tint/998.wgsl.expected.spvasm +++ b/test/tint/bug/tint/998.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 24 +; Bound: 25 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -47,11 +47,12 @@ %uint_0 = OpConstant %uint 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %_ptr_Private_uint = OpTypePointer Private %uint + %24 = OpConstantNull %uint %main = OpFunction %void None %14 %17 = OpLabel %20 = OpAccessChain %_ptr_Uniform_uint %constants %uint_0 %21 = OpLoad %uint %20 %23 = OpAccessChain %_ptr_Private_uint %s %uint_0 %21 - OpStore %23 %uint_0 + OpStore %23 %24 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/extractBits/scalar/i32.spvasm.expected.spvasm b/test/tint/builtins/extractBits/scalar/i32.spvasm.expected.spvasm index 9281c0e37e..42c93f6e10 100644 --- a/test/tint/builtins/extractBits/scalar/i32.spvasm.expected.spvasm +++ b/test/tint/builtins/extractBits/scalar/i32.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 36 +; Bound: 34 ; Schema: 0 OpCapability Shader %10 = OpExtInstImport "GLSL.std.450" @@ -23,12 +23,10 @@ %uint_32 = OpConstant %uint 32 %void = OpTypeVoid %16 = OpTypeFunction %void - %int_0 = OpConstant %int 0 + %20 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %23 = OpConstantNull %int - %uint_0 = OpConstant %uint 0 + %23 = OpConstantNull %uint %_ptr_Function_uint = OpTypePointer Function %uint - %27 = OpConstantNull %uint %tint_extract_bits = OpFunction %int None %1 %v = OpFunctionParameter %int %offset = OpFunctionParameter %uint @@ -43,20 +41,20 @@ OpFunctionEnd %f_1 = OpFunction %void None %16 %19 = OpLabel - %v_0 = OpVariable %_ptr_Function_int Function %23 - %offset_1 = OpVariable %_ptr_Function_uint Function %27 - %count_0 = OpVariable %_ptr_Function_uint Function %27 - OpStore %v_0 %int_0 - OpStore %offset_1 %uint_0 - OpStore %count_0 %uint_0 - %29 = OpLoad %int %v_0 - %30 = OpLoad %uint %offset_1 - %31 = OpLoad %uint %count_0 - %32 = OpFunctionCall %int %tint_extract_bits %29 %30 %31 + %v_0 = OpVariable %_ptr_Function_int Function %20 + %offset_1 = OpVariable %_ptr_Function_uint Function %23 + %count_0 = OpVariable %_ptr_Function_uint Function %23 + OpStore %v_0 %20 + OpStore %offset_1 %23 + OpStore %count_0 %23 + %27 = OpLoad %int %v_0 + %28 = OpLoad %uint %offset_1 + %29 = OpLoad %uint %count_0 + %30 = OpFunctionCall %int %tint_extract_bits %27 %28 %29 OpReturn OpFunctionEnd %f = OpFunction %void None %16 - %34 = OpLabel - %35 = OpFunctionCall %void %f_1 + %32 = OpLabel + %33 = OpFunctionCall %void %f_1 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/extractBits/scalar/u32.spvasm.expected.spvasm b/test/tint/builtins/extractBits/scalar/u32.spvasm.expected.spvasm index 67c95bdef4..93bb97c35e 100644 --- a/test/tint/builtins/extractBits/scalar/u32.spvasm.expected.spvasm +++ b/test/tint/builtins/extractBits/scalar/u32.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 32 +; Bound: 31 ; Schema: 0 OpCapability Shader %9 = OpExtInstImport "GLSL.std.450" @@ -22,9 +22,8 @@ %uint_32 = OpConstant %uint 32 %void = OpTypeVoid %15 = OpTypeFunction %void - %uint_0 = OpConstant %uint 0 + %19 = OpConstantNull %uint %_ptr_Function_uint = OpTypePointer Function %uint - %22 = OpConstantNull %uint %tint_extract_bits = OpFunction %uint None %1 %v = OpFunctionParameter %uint %offset = OpFunctionParameter %uint @@ -39,20 +38,20 @@ OpFunctionEnd %f_1 = OpFunction %void None %15 %18 = OpLabel - %v_0 = OpVariable %_ptr_Function_uint Function %22 - %offset_1 = OpVariable %_ptr_Function_uint Function %22 - %count_0 = OpVariable %_ptr_Function_uint Function %22 - OpStore %v_0 %uint_0 - OpStore %offset_1 %uint_0 - OpStore %count_0 %uint_0 - %25 = OpLoad %uint %v_0 - %26 = OpLoad %uint %offset_1 - %27 = OpLoad %uint %count_0 - %28 = OpFunctionCall %uint %tint_extract_bits %25 %26 %27 + %v_0 = OpVariable %_ptr_Function_uint Function %19 + %offset_1 = OpVariable %_ptr_Function_uint Function %19 + %count_0 = OpVariable %_ptr_Function_uint Function %19 + OpStore %v_0 %19 + OpStore %offset_1 %19 + OpStore %count_0 %19 + %24 = OpLoad %uint %v_0 + %25 = OpLoad %uint %offset_1 + %26 = OpLoad %uint %count_0 + %27 = OpFunctionCall %uint %tint_extract_bits %24 %25 %26 OpReturn OpFunctionEnd %f = OpFunction %void None %15 - %30 = OpLabel - %31 = OpFunctionCall %void %f_1 + %29 = OpLabel + %30 = OpFunctionCall %void %f_1 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/extractBits/vec3/i32.spvasm.expected.spvasm b/test/tint/builtins/extractBits/vec3/i32.spvasm.expected.spvasm index 2ef08d08bf..3d34096e77 100644 --- a/test/tint/builtins/extractBits/vec3/i32.spvasm.expected.spvasm +++ b/test/tint/builtins/extractBits/vec3/i32.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 36 +; Bound: 35 ; Schema: 0 OpCapability Shader %11 = OpExtInstImport "GLSL.std.450" @@ -26,9 +26,8 @@ %17 = OpTypeFunction %void %21 = OpConstantNull %v3int %_ptr_Function_v3int = OpTypePointer Function %v3int - %uint_0 = OpConstant %uint 0 + %24 = OpConstantNull %uint %_ptr_Function_uint = OpTypePointer Function %uint - %27 = OpConstantNull %uint %tint_extract_bits = OpFunction %v3int None %1 %v = OpFunctionParameter %v3int %offset = OpFunctionParameter %uint @@ -44,19 +43,19 @@ %f_1 = OpFunction %void None %17 %20 = OpLabel %v_0 = OpVariable %_ptr_Function_v3int Function %21 - %offset_1 = OpVariable %_ptr_Function_uint Function %27 - %count_0 = OpVariable %_ptr_Function_uint Function %27 + %offset_1 = OpVariable %_ptr_Function_uint Function %24 + %count_0 = OpVariable %_ptr_Function_uint Function %24 OpStore %v_0 %21 - OpStore %offset_1 %uint_0 - OpStore %count_0 %uint_0 - %29 = OpLoad %v3int %v_0 - %30 = OpLoad %uint %offset_1 - %31 = OpLoad %uint %count_0 - %32 = OpFunctionCall %v3int %tint_extract_bits %29 %30 %31 + OpStore %offset_1 %24 + OpStore %count_0 %24 + %28 = OpLoad %v3int %v_0 + %29 = OpLoad %uint %offset_1 + %30 = OpLoad %uint %count_0 + %31 = OpFunctionCall %v3int %tint_extract_bits %28 %29 %30 OpReturn OpFunctionEnd %f = OpFunction %void None %17 - %34 = OpLabel - %35 = OpFunctionCall %void %f_1 + %33 = OpLabel + %34 = OpFunctionCall %void %f_1 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/extractBits/vec3/u32.spvasm.expected.spvasm b/test/tint/builtins/extractBits/vec3/u32.spvasm.expected.spvasm index d5800cc7be..61b4732061 100644 --- a/test/tint/builtins/extractBits/vec3/u32.spvasm.expected.spvasm +++ b/test/tint/builtins/extractBits/vec3/u32.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 35 +; Bound: 34 ; Schema: 0 OpCapability Shader %10 = OpExtInstImport "GLSL.std.450" @@ -25,9 +25,8 @@ %16 = OpTypeFunction %void %20 = OpConstantNull %v3uint %_ptr_Function_v3uint = OpTypePointer Function %v3uint - %uint_0 = OpConstant %uint 0 + %23 = OpConstantNull %uint %_ptr_Function_uint = OpTypePointer Function %uint - %26 = OpConstantNull %uint %tint_extract_bits = OpFunction %v3uint None %1 %v = OpFunctionParameter %v3uint %offset = OpFunctionParameter %uint @@ -43,19 +42,19 @@ %f_1 = OpFunction %void None %16 %19 = OpLabel %v_0 = OpVariable %_ptr_Function_v3uint Function %20 - %offset_1 = OpVariable %_ptr_Function_uint Function %26 - %count_0 = OpVariable %_ptr_Function_uint Function %26 + %offset_1 = OpVariable %_ptr_Function_uint Function %23 + %count_0 = OpVariable %_ptr_Function_uint Function %23 OpStore %v_0 %20 - OpStore %offset_1 %uint_0 - OpStore %count_0 %uint_0 - %28 = OpLoad %v3uint %v_0 - %29 = OpLoad %uint %offset_1 - %30 = OpLoad %uint %count_0 - %31 = OpFunctionCall %v3uint %tint_extract_bits %28 %29 %30 + OpStore %offset_1 %23 + OpStore %count_0 %23 + %27 = OpLoad %v3uint %v_0 + %28 = OpLoad %uint %offset_1 + %29 = OpLoad %uint %count_0 + %30 = OpFunctionCall %v3uint %tint_extract_bits %27 %28 %29 OpReturn OpFunctionEnd %f = OpFunction %void None %16 - %33 = OpLabel - %34 = OpFunctionCall %void %f_1 + %32 = OpLabel + %33 = OpFunctionCall %void %f_1 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/countLeadingZeros/208d46.wgsl.expected.spvasm b/test/tint/builtins/gen/countLeadingZeros/208d46.wgsl.expected.spvasm index 536612a98f..472bf589bf 100644 --- a/test/tint/builtins/gen/countLeadingZeros/208d46.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/countLeadingZeros/208d46.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 82 +; Bound: 81 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -38,7 +38,6 @@ %uint_65535 = OpConstant %uint 65535 %bool = OpTypeBool %uint_16 = OpConstant %uint 16 - %uint_0 = OpConstant %uint 0 %uint_16777215 = OpConstant %uint 16777215 %uint_8 = OpConstant %uint 8 %uint_268435455 = OpConstant %uint 268435455 @@ -48,8 +47,8 @@ %uint_2147483647 = OpConstant %uint 2147483647 %uint_1 = OpConstant %uint 1 %void = OpTypeVoid - %62 = OpTypeFunction %void - %68 = OpTypeFunction %v4float + %61 = OpTypeFunction %void + %67 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_count_leading_zeros = OpFunction %uint None %9 %v = OpFunctionParameter %uint @@ -58,67 +57,67 @@ OpStore %x %v %19 = OpLoad %uint %x %21 = OpULessThanEqual %bool %19 %uint_65535 - %18 = OpSelect %uint %21 %uint_16 %uint_0 - %25 = OpLoad %uint %x - %26 = OpShiftLeftLogical %uint %25 %18 - OpStore %x %26 - %28 = OpLoad %uint %x - %30 = OpULessThanEqual %bool %28 %uint_16777215 - %27 = OpSelect %uint %30 %uint_8 %uint_0 - %32 = OpLoad %uint %x - %33 = OpShiftLeftLogical %uint %32 %27 - OpStore %x %33 - %35 = OpLoad %uint %x - %37 = OpULessThanEqual %bool %35 %uint_268435455 - %34 = OpSelect %uint %37 %uint_4 %uint_0 - %39 = OpLoad %uint %x - %40 = OpShiftLeftLogical %uint %39 %34 - OpStore %x %40 - %42 = OpLoad %uint %x - %44 = OpULessThanEqual %bool %42 %uint_1073741823 - %41 = OpSelect %uint %44 %uint_2 %uint_0 - %46 = OpLoad %uint %x - %47 = OpShiftLeftLogical %uint %46 %41 - OpStore %x %47 - %49 = OpLoad %uint %x - %51 = OpULessThanEqual %bool %49 %uint_2147483647 - %48 = OpSelect %uint %51 %uint_1 %uint_0 - %54 = OpLoad %uint %x - %55 = OpIEqual %bool %54 %uint_0 - %53 = OpSelect %uint %55 %uint_1 %uint_0 - %57 = OpBitwiseOr %uint %18 %27 - %58 = OpBitwiseOr %uint %57 %34 - %59 = OpBitwiseOr %uint %58 %41 - %60 = OpBitwiseOr %uint %59 %48 - %61 = OpIAdd %uint %60 %53 - OpReturnValue %61 + %18 = OpSelect %uint %21 %uint_16 %17 + %24 = OpLoad %uint %x + %25 = OpShiftLeftLogical %uint %24 %18 + OpStore %x %25 + %27 = OpLoad %uint %x + %29 = OpULessThanEqual %bool %27 %uint_16777215 + %26 = OpSelect %uint %29 %uint_8 %17 + %31 = OpLoad %uint %x + %32 = OpShiftLeftLogical %uint %31 %26 + OpStore %x %32 + %34 = OpLoad %uint %x + %36 = OpULessThanEqual %bool %34 %uint_268435455 + %33 = OpSelect %uint %36 %uint_4 %17 + %38 = OpLoad %uint %x + %39 = OpShiftLeftLogical %uint %38 %33 + OpStore %x %39 + %41 = OpLoad %uint %x + %43 = OpULessThanEqual %bool %41 %uint_1073741823 + %40 = OpSelect %uint %43 %uint_2 %17 + %45 = OpLoad %uint %x + %46 = OpShiftLeftLogical %uint %45 %40 + OpStore %x %46 + %48 = OpLoad %uint %x + %50 = OpULessThanEqual %bool %48 %uint_2147483647 + %47 = OpSelect %uint %50 %uint_1 %17 + %53 = OpLoad %uint %x + %54 = OpIEqual %bool %53 %17 + %52 = OpSelect %uint %54 %uint_1 %17 + %56 = OpBitwiseOr %uint %18 %26 + %57 = OpBitwiseOr %uint %56 %33 + %58 = OpBitwiseOr %uint %57 %40 + %59 = OpBitwiseOr %uint %58 %47 + %60 = OpIAdd %uint %59 %52 + OpReturnValue %60 OpFunctionEnd -%countLeadingZeros_208d46 = OpFunction %void None %62 - %65 = OpLabel +%countLeadingZeros_208d46 = OpFunction %void None %61 + %64 = OpLabel %res = OpVariable %_ptr_Function_uint Function %17 - %66 = OpFunctionCall %uint %tint_count_leading_zeros %uint_1 - OpStore %res %66 + %65 = OpFunctionCall %uint %tint_count_leading_zeros %uint_1 + OpStore %res %65 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %68 - %70 = OpLabel - %71 = OpFunctionCall %void %countLeadingZeros_208d46 +%vertex_main_inner = OpFunction %v4float None %67 + %69 = OpLabel + %70 = OpFunctionCall %void %countLeadingZeros_208d46 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %62 - %73 = OpLabel - %74 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %74 +%vertex_main = OpFunction %void None %61 + %72 = OpLabel + %73 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %73 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %62 - %77 = OpLabel - %78 = OpFunctionCall %void %countLeadingZeros_208d46 +%fragment_main = OpFunction %void None %61 + %76 = OpLabel + %77 = OpFunctionCall %void %countLeadingZeros_208d46 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %62 - %80 = OpLabel - %81 = OpFunctionCall %void %countLeadingZeros_208d46 +%compute_main = OpFunction %void None %61 + %79 = OpLabel + %80 = OpFunctionCall %void %countLeadingZeros_208d46 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/countLeadingZeros/6d4656.wgsl.expected.spvasm b/test/tint/builtins/gen/countLeadingZeros/6d4656.wgsl.expected.spvasm index 6990a3605b..4e73e3f0a9 100644 --- a/test/tint/builtins/gen/countLeadingZeros/6d4656.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/countLeadingZeros/6d4656.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 86 +; Bound: 85 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -39,7 +39,6 @@ %uint_65535 = OpConstant %uint 65535 %bool = OpTypeBool %uint_16 = OpConstant %uint 16 - %uint_0 = OpConstant %uint 0 %uint_16777215 = OpConstant %uint 16777215 %uint_8 = OpConstant %uint 8 %uint_268435455 = OpConstant %uint 268435455 @@ -49,11 +48,11 @@ %uint_2147483647 = OpConstant %uint 2147483647 %uint_1 = OpConstant %uint 1 %void = OpTypeVoid - %63 = OpTypeFunction %void + %62 = OpTypeFunction %void %int_1 = OpConstant %int 1 %_ptr_Function_int = OpTypePointer Function %int - %71 = OpConstantNull %int - %72 = OpTypeFunction %v4float + %70 = OpConstantNull %int + %71 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_count_leading_zeros = OpFunction %int None %9 %v = OpFunctionParameter %int @@ -63,68 +62,68 @@ OpStore %x %14 %20 = OpLoad %uint %x %22 = OpULessThanEqual %bool %20 %uint_65535 - %19 = OpSelect %uint %22 %uint_16 %uint_0 - %26 = OpLoad %uint %x - %27 = OpShiftLeftLogical %uint %26 %19 - OpStore %x %27 - %29 = OpLoad %uint %x - %31 = OpULessThanEqual %bool %29 %uint_16777215 - %28 = OpSelect %uint %31 %uint_8 %uint_0 - %33 = OpLoad %uint %x - %34 = OpShiftLeftLogical %uint %33 %28 - OpStore %x %34 - %36 = OpLoad %uint %x - %38 = OpULessThanEqual %bool %36 %uint_268435455 - %35 = OpSelect %uint %38 %uint_4 %uint_0 - %40 = OpLoad %uint %x - %41 = OpShiftLeftLogical %uint %40 %35 - OpStore %x %41 - %43 = OpLoad %uint %x - %45 = OpULessThanEqual %bool %43 %uint_1073741823 - %42 = OpSelect %uint %45 %uint_2 %uint_0 - %47 = OpLoad %uint %x - %48 = OpShiftLeftLogical %uint %47 %42 - OpStore %x %48 - %50 = OpLoad %uint %x - %52 = OpULessThanEqual %bool %50 %uint_2147483647 - %49 = OpSelect %uint %52 %uint_1 %uint_0 - %55 = OpLoad %uint %x - %56 = OpIEqual %bool %55 %uint_0 - %54 = OpSelect %uint %56 %uint_1 %uint_0 - %58 = OpBitwiseOr %uint %19 %28 - %59 = OpBitwiseOr %uint %58 %35 - %60 = OpBitwiseOr %uint %59 %42 - %61 = OpBitwiseOr %uint %60 %49 - %62 = OpIAdd %uint %61 %54 - %57 = OpBitcast %int %62 - OpReturnValue %57 + %19 = OpSelect %uint %22 %uint_16 %18 + %25 = OpLoad %uint %x + %26 = OpShiftLeftLogical %uint %25 %19 + OpStore %x %26 + %28 = OpLoad %uint %x + %30 = OpULessThanEqual %bool %28 %uint_16777215 + %27 = OpSelect %uint %30 %uint_8 %18 + %32 = OpLoad %uint %x + %33 = OpShiftLeftLogical %uint %32 %27 + OpStore %x %33 + %35 = OpLoad %uint %x + %37 = OpULessThanEqual %bool %35 %uint_268435455 + %34 = OpSelect %uint %37 %uint_4 %18 + %39 = OpLoad %uint %x + %40 = OpShiftLeftLogical %uint %39 %34 + OpStore %x %40 + %42 = OpLoad %uint %x + %44 = OpULessThanEqual %bool %42 %uint_1073741823 + %41 = OpSelect %uint %44 %uint_2 %18 + %46 = OpLoad %uint %x + %47 = OpShiftLeftLogical %uint %46 %41 + OpStore %x %47 + %49 = OpLoad %uint %x + %51 = OpULessThanEqual %bool %49 %uint_2147483647 + %48 = OpSelect %uint %51 %uint_1 %18 + %54 = OpLoad %uint %x + %55 = OpIEqual %bool %54 %18 + %53 = OpSelect %uint %55 %uint_1 %18 + %57 = OpBitwiseOr %uint %19 %27 + %58 = OpBitwiseOr %uint %57 %34 + %59 = OpBitwiseOr %uint %58 %41 + %60 = OpBitwiseOr %uint %59 %48 + %61 = OpIAdd %uint %60 %53 + %56 = OpBitcast %int %61 + OpReturnValue %56 OpFunctionEnd -%countLeadingZeros_6d4656 = OpFunction %void None %63 - %66 = OpLabel - %res = OpVariable %_ptr_Function_int Function %71 - %67 = OpFunctionCall %int %tint_count_leading_zeros %int_1 - OpStore %res %67 +%countLeadingZeros_6d4656 = OpFunction %void None %62 + %65 = OpLabel + %res = OpVariable %_ptr_Function_int Function %70 + %66 = OpFunctionCall %int %tint_count_leading_zeros %int_1 + OpStore %res %66 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %72 - %74 = OpLabel - %75 = OpFunctionCall %void %countLeadingZeros_6d4656 +%vertex_main_inner = OpFunction %v4float None %71 + %73 = OpLabel + %74 = OpFunctionCall %void %countLeadingZeros_6d4656 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %63 - %77 = OpLabel - %78 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %78 +%vertex_main = OpFunction %void None %62 + %76 = OpLabel + %77 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %77 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %63 - %81 = OpLabel - %82 = OpFunctionCall %void %countLeadingZeros_6d4656 +%fragment_main = OpFunction %void None %62 + %80 = OpLabel + %81 = OpFunctionCall %void %countLeadingZeros_6d4656 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %63 - %84 = OpLabel - %85 = OpFunctionCall %void %countLeadingZeros_6d4656 +%compute_main = OpFunction %void None %62 + %83 = OpLabel + %84 = OpFunctionCall %void %countLeadingZeros_6d4656 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/countLeadingZeros/70783f.wgsl.expected.spvasm b/test/tint/builtins/gen/countLeadingZeros/70783f.wgsl.expected.spvasm index df3cb9b4d7..76252b2ef1 100644 --- a/test/tint/builtins/gen/countLeadingZeros/70783f.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/countLeadingZeros/70783f.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 95 +; Bound: 93 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -42,27 +42,25 @@ %v2bool = OpTypeVector %bool 2 %uint_16 = OpConstant %uint 16 %27 = OpConstantComposite %v2uint %uint_16 %uint_16 - %uint_0 = OpConstant %uint 0 - %29 = OpConstantComposite %v2uint %uint_0 %uint_0 %uint_16777215 = OpConstant %uint 16777215 - %35 = OpConstantComposite %v2uint %uint_16777215 %uint_16777215 + %33 = OpConstantComposite %v2uint %uint_16777215 %uint_16777215 %uint_8 = OpConstant %uint 8 - %38 = OpConstantComposite %v2uint %uint_8 %uint_8 + %36 = OpConstantComposite %v2uint %uint_8 %uint_8 %uint_268435455 = OpConstant %uint 268435455 - %44 = OpConstantComposite %v2uint %uint_268435455 %uint_268435455 + %42 = OpConstantComposite %v2uint %uint_268435455 %uint_268435455 %uint_4 = OpConstant %uint 4 - %47 = OpConstantComposite %v2uint %uint_4 %uint_4 + %45 = OpConstantComposite %v2uint %uint_4 %uint_4 %uint_1073741823 = OpConstant %uint 1073741823 - %53 = OpConstantComposite %v2uint %uint_1073741823 %uint_1073741823 + %51 = OpConstantComposite %v2uint %uint_1073741823 %uint_1073741823 %uint_2 = OpConstant %uint 2 - %56 = OpConstantComposite %v2uint %uint_2 %uint_2 + %54 = OpConstantComposite %v2uint %uint_2 %uint_2 %uint_2147483647 = OpConstant %uint 2147483647 - %62 = OpConstantComposite %v2uint %uint_2147483647 %uint_2147483647 + %60 = OpConstantComposite %v2uint %uint_2147483647 %uint_2147483647 %uint_1 = OpConstant %uint 1 - %65 = OpConstantComposite %v2uint %uint_1 %uint_1 + %63 = OpConstantComposite %v2uint %uint_1 %uint_1 %void = OpTypeVoid - %75 = OpTypeFunction %void - %81 = OpTypeFunction %v4float + %73 = OpTypeFunction %void + %79 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_count_leading_zeros = OpFunction %v2uint None %9 %v = OpFunctionParameter %v2uint @@ -71,67 +69,67 @@ OpStore %x %v %20 = OpLoad %v2uint %x %23 = OpULessThanEqual %v2bool %20 %22 - %19 = OpSelect %v2uint %23 %27 %29 - %30 = OpLoad %v2uint %x - %31 = OpShiftLeftLogical %v2uint %30 %19 - OpStore %x %31 - %33 = OpLoad %v2uint %x - %36 = OpULessThanEqual %v2bool %33 %35 - %32 = OpSelect %v2uint %36 %38 %29 - %39 = OpLoad %v2uint %x - %40 = OpShiftLeftLogical %v2uint %39 %32 - OpStore %x %40 - %42 = OpLoad %v2uint %x - %45 = OpULessThanEqual %v2bool %42 %44 - %41 = OpSelect %v2uint %45 %47 %29 - %48 = OpLoad %v2uint %x - %49 = OpShiftLeftLogical %v2uint %48 %41 - OpStore %x %49 - %51 = OpLoad %v2uint %x - %54 = OpULessThanEqual %v2bool %51 %53 - %50 = OpSelect %v2uint %54 %56 %29 - %57 = OpLoad %v2uint %x - %58 = OpShiftLeftLogical %v2uint %57 %50 - OpStore %x %58 - %60 = OpLoad %v2uint %x - %63 = OpULessThanEqual %v2bool %60 %62 - %59 = OpSelect %v2uint %63 %65 %29 - %67 = OpLoad %v2uint %x - %68 = OpIEqual %v2bool %67 %29 - %66 = OpSelect %v2uint %68 %65 %29 - %70 = OpBitwiseOr %v2uint %19 %32 - %71 = OpBitwiseOr %v2uint %70 %41 - %72 = OpBitwiseOr %v2uint %71 %50 - %73 = OpBitwiseOr %v2uint %72 %59 - %74 = OpIAdd %v2uint %73 %66 - OpReturnValue %74 + %19 = OpSelect %v2uint %23 %27 %18 + %28 = OpLoad %v2uint %x + %29 = OpShiftLeftLogical %v2uint %28 %19 + OpStore %x %29 + %31 = OpLoad %v2uint %x + %34 = OpULessThanEqual %v2bool %31 %33 + %30 = OpSelect %v2uint %34 %36 %18 + %37 = OpLoad %v2uint %x + %38 = OpShiftLeftLogical %v2uint %37 %30 + OpStore %x %38 + %40 = OpLoad %v2uint %x + %43 = OpULessThanEqual %v2bool %40 %42 + %39 = OpSelect %v2uint %43 %45 %18 + %46 = OpLoad %v2uint %x + %47 = OpShiftLeftLogical %v2uint %46 %39 + OpStore %x %47 + %49 = OpLoad %v2uint %x + %52 = OpULessThanEqual %v2bool %49 %51 + %48 = OpSelect %v2uint %52 %54 %18 + %55 = OpLoad %v2uint %x + %56 = OpShiftLeftLogical %v2uint %55 %48 + OpStore %x %56 + %58 = OpLoad %v2uint %x + %61 = OpULessThanEqual %v2bool %58 %60 + %57 = OpSelect %v2uint %61 %63 %18 + %65 = OpLoad %v2uint %x + %66 = OpIEqual %v2bool %65 %18 + %64 = OpSelect %v2uint %66 %63 %18 + %68 = OpBitwiseOr %v2uint %19 %30 + %69 = OpBitwiseOr %v2uint %68 %39 + %70 = OpBitwiseOr %v2uint %69 %48 + %71 = OpBitwiseOr %v2uint %70 %57 + %72 = OpIAdd %v2uint %71 %64 + OpReturnValue %72 OpFunctionEnd -%countLeadingZeros_70783f = OpFunction %void None %75 - %78 = OpLabel +%countLeadingZeros_70783f = OpFunction %void None %73 + %76 = OpLabel %res = OpVariable %_ptr_Function_v2uint Function %18 - %79 = OpFunctionCall %v2uint %tint_count_leading_zeros %18 - OpStore %res %79 + %77 = OpFunctionCall %v2uint %tint_count_leading_zeros %18 + OpStore %res %77 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %81 - %83 = OpLabel - %84 = OpFunctionCall %void %countLeadingZeros_70783f +%vertex_main_inner = OpFunction %v4float None %79 + %81 = OpLabel + %82 = OpFunctionCall %void %countLeadingZeros_70783f OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %75 - %86 = OpLabel - %87 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %87 +%vertex_main = OpFunction %void None %73 + %84 = OpLabel + %85 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %85 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %75 - %90 = OpLabel - %91 = OpFunctionCall %void %countLeadingZeros_70783f +%fragment_main = OpFunction %void None %73 + %88 = OpLabel + %89 = OpFunctionCall %void %countLeadingZeros_70783f OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %75 - %93 = OpLabel - %94 = OpFunctionCall %void %countLeadingZeros_70783f +%compute_main = OpFunction %void None %73 + %91 = OpLabel + %92 = OpFunctionCall %void %countLeadingZeros_70783f OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/countLeadingZeros/7c38a6.wgsl.expected.spvasm b/test/tint/builtins/gen/countLeadingZeros/7c38a6.wgsl.expected.spvasm index 05320c5696..f710c4e253 100644 --- a/test/tint/builtins/gen/countLeadingZeros/7c38a6.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/countLeadingZeros/7c38a6.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 99 +; Bound: 97 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -44,29 +44,27 @@ %v3bool = OpTypeVector %bool 3 %uint_16 = OpConstant %uint 16 %29 = OpConstantComposite %v3uint %uint_16 %uint_16 %uint_16 - %uint_0 = OpConstant %uint 0 - %31 = OpConstantComposite %v3uint %uint_0 %uint_0 %uint_0 %uint_16777215 = OpConstant %uint 16777215 - %37 = OpConstantComposite %v3uint %uint_16777215 %uint_16777215 %uint_16777215 + %35 = OpConstantComposite %v3uint %uint_16777215 %uint_16777215 %uint_16777215 %uint_8 = OpConstant %uint 8 - %40 = OpConstantComposite %v3uint %uint_8 %uint_8 %uint_8 + %38 = OpConstantComposite %v3uint %uint_8 %uint_8 %uint_8 %uint_268435455 = OpConstant %uint 268435455 - %46 = OpConstantComposite %v3uint %uint_268435455 %uint_268435455 %uint_268435455 + %44 = OpConstantComposite %v3uint %uint_268435455 %uint_268435455 %uint_268435455 %uint_4 = OpConstant %uint 4 - %49 = OpConstantComposite %v3uint %uint_4 %uint_4 %uint_4 + %47 = OpConstantComposite %v3uint %uint_4 %uint_4 %uint_4 %uint_1073741823 = OpConstant %uint 1073741823 - %55 = OpConstantComposite %v3uint %uint_1073741823 %uint_1073741823 %uint_1073741823 + %53 = OpConstantComposite %v3uint %uint_1073741823 %uint_1073741823 %uint_1073741823 %uint_2 = OpConstant %uint 2 - %58 = OpConstantComposite %v3uint %uint_2 %uint_2 %uint_2 + %56 = OpConstantComposite %v3uint %uint_2 %uint_2 %uint_2 %uint_2147483647 = OpConstant %uint 2147483647 - %64 = OpConstantComposite %v3uint %uint_2147483647 %uint_2147483647 %uint_2147483647 + %62 = OpConstantComposite %v3uint %uint_2147483647 %uint_2147483647 %uint_2147483647 %uint_1 = OpConstant %uint 1 - %67 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 + %65 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %void = OpTypeVoid - %77 = OpTypeFunction %void - %82 = OpConstantNull %v3int + %75 = OpTypeFunction %void + %80 = OpConstantNull %v3int %_ptr_Function_v3int = OpTypePointer Function %v3int - %85 = OpTypeFunction %v4float + %83 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_count_leading_zeros = OpFunction %v3int None %9 %v = OpFunctionParameter %v3int @@ -76,68 +74,68 @@ OpStore %x %15 %22 = OpLoad %v3uint %x %25 = OpULessThanEqual %v3bool %22 %24 - %21 = OpSelect %v3uint %25 %29 %31 - %32 = OpLoad %v3uint %x - %33 = OpShiftLeftLogical %v3uint %32 %21 - OpStore %x %33 - %35 = OpLoad %v3uint %x - %38 = OpULessThanEqual %v3bool %35 %37 - %34 = OpSelect %v3uint %38 %40 %31 - %41 = OpLoad %v3uint %x - %42 = OpShiftLeftLogical %v3uint %41 %34 - OpStore %x %42 - %44 = OpLoad %v3uint %x - %47 = OpULessThanEqual %v3bool %44 %46 - %43 = OpSelect %v3uint %47 %49 %31 - %50 = OpLoad %v3uint %x - %51 = OpShiftLeftLogical %v3uint %50 %43 - OpStore %x %51 - %53 = OpLoad %v3uint %x - %56 = OpULessThanEqual %v3bool %53 %55 - %52 = OpSelect %v3uint %56 %58 %31 - %59 = OpLoad %v3uint %x - %60 = OpShiftLeftLogical %v3uint %59 %52 - OpStore %x %60 - %62 = OpLoad %v3uint %x - %65 = OpULessThanEqual %v3bool %62 %64 - %61 = OpSelect %v3uint %65 %67 %31 - %69 = OpLoad %v3uint %x - %70 = OpIEqual %v3bool %69 %31 - %68 = OpSelect %v3uint %70 %67 %31 - %72 = OpBitwiseOr %v3uint %21 %34 - %73 = OpBitwiseOr %v3uint %72 %43 - %74 = OpBitwiseOr %v3uint %73 %52 - %75 = OpBitwiseOr %v3uint %74 %61 - %76 = OpIAdd %v3uint %75 %68 - %71 = OpBitcast %v3int %76 - OpReturnValue %71 + %21 = OpSelect %v3uint %25 %29 %20 + %30 = OpLoad %v3uint %x + %31 = OpShiftLeftLogical %v3uint %30 %21 + OpStore %x %31 + %33 = OpLoad %v3uint %x + %36 = OpULessThanEqual %v3bool %33 %35 + %32 = OpSelect %v3uint %36 %38 %20 + %39 = OpLoad %v3uint %x + %40 = OpShiftLeftLogical %v3uint %39 %32 + OpStore %x %40 + %42 = OpLoad %v3uint %x + %45 = OpULessThanEqual %v3bool %42 %44 + %41 = OpSelect %v3uint %45 %47 %20 + %48 = OpLoad %v3uint %x + %49 = OpShiftLeftLogical %v3uint %48 %41 + OpStore %x %49 + %51 = OpLoad %v3uint %x + %54 = OpULessThanEqual %v3bool %51 %53 + %50 = OpSelect %v3uint %54 %56 %20 + %57 = OpLoad %v3uint %x + %58 = OpShiftLeftLogical %v3uint %57 %50 + OpStore %x %58 + %60 = OpLoad %v3uint %x + %63 = OpULessThanEqual %v3bool %60 %62 + %59 = OpSelect %v3uint %63 %65 %20 + %67 = OpLoad %v3uint %x + %68 = OpIEqual %v3bool %67 %20 + %66 = OpSelect %v3uint %68 %65 %20 + %70 = OpBitwiseOr %v3uint %21 %32 + %71 = OpBitwiseOr %v3uint %70 %41 + %72 = OpBitwiseOr %v3uint %71 %50 + %73 = OpBitwiseOr %v3uint %72 %59 + %74 = OpIAdd %v3uint %73 %66 + %69 = OpBitcast %v3int %74 + OpReturnValue %69 OpFunctionEnd -%countLeadingZeros_7c38a6 = OpFunction %void None %77 - %80 = OpLabel - %res = OpVariable %_ptr_Function_v3int Function %82 - %81 = OpFunctionCall %v3int %tint_count_leading_zeros %82 - OpStore %res %81 +%countLeadingZeros_7c38a6 = OpFunction %void None %75 + %78 = OpLabel + %res = OpVariable %_ptr_Function_v3int Function %80 + %79 = OpFunctionCall %v3int %tint_count_leading_zeros %80 + OpStore %res %79 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %85 - %87 = OpLabel - %88 = OpFunctionCall %void %countLeadingZeros_7c38a6 +%vertex_main_inner = OpFunction %v4float None %83 + %85 = OpLabel + %86 = OpFunctionCall %void %countLeadingZeros_7c38a6 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %77 - %90 = OpLabel - %91 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %91 +%vertex_main = OpFunction %void None %75 + %88 = OpLabel + %89 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %89 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %77 - %94 = OpLabel - %95 = OpFunctionCall %void %countLeadingZeros_7c38a6 +%fragment_main = OpFunction %void None %75 + %92 = OpLabel + %93 = OpFunctionCall %void %countLeadingZeros_7c38a6 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %77 - %97 = OpLabel - %98 = OpFunctionCall %void %countLeadingZeros_7c38a6 +%compute_main = OpFunction %void None %75 + %95 = OpLabel + %96 = OpFunctionCall %void %countLeadingZeros_7c38a6 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/countLeadingZeros/858d40.wgsl.expected.spvasm b/test/tint/builtins/gen/countLeadingZeros/858d40.wgsl.expected.spvasm index 48d5c97b37..67d9ae4bdb 100644 --- a/test/tint/builtins/gen/countLeadingZeros/858d40.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/countLeadingZeros/858d40.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 99 +; Bound: 97 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -44,29 +44,27 @@ %v2bool = OpTypeVector %bool 2 %uint_16 = OpConstant %uint 16 %29 = OpConstantComposite %v2uint %uint_16 %uint_16 - %uint_0 = OpConstant %uint 0 - %31 = OpConstantComposite %v2uint %uint_0 %uint_0 %uint_16777215 = OpConstant %uint 16777215 - %37 = OpConstantComposite %v2uint %uint_16777215 %uint_16777215 + %35 = OpConstantComposite %v2uint %uint_16777215 %uint_16777215 %uint_8 = OpConstant %uint 8 - %40 = OpConstantComposite %v2uint %uint_8 %uint_8 + %38 = OpConstantComposite %v2uint %uint_8 %uint_8 %uint_268435455 = OpConstant %uint 268435455 - %46 = OpConstantComposite %v2uint %uint_268435455 %uint_268435455 + %44 = OpConstantComposite %v2uint %uint_268435455 %uint_268435455 %uint_4 = OpConstant %uint 4 - %49 = OpConstantComposite %v2uint %uint_4 %uint_4 + %47 = OpConstantComposite %v2uint %uint_4 %uint_4 %uint_1073741823 = OpConstant %uint 1073741823 - %55 = OpConstantComposite %v2uint %uint_1073741823 %uint_1073741823 + %53 = OpConstantComposite %v2uint %uint_1073741823 %uint_1073741823 %uint_2 = OpConstant %uint 2 - %58 = OpConstantComposite %v2uint %uint_2 %uint_2 + %56 = OpConstantComposite %v2uint %uint_2 %uint_2 %uint_2147483647 = OpConstant %uint 2147483647 - %64 = OpConstantComposite %v2uint %uint_2147483647 %uint_2147483647 + %62 = OpConstantComposite %v2uint %uint_2147483647 %uint_2147483647 %uint_1 = OpConstant %uint 1 - %67 = OpConstantComposite %v2uint %uint_1 %uint_1 + %65 = OpConstantComposite %v2uint %uint_1 %uint_1 %void = OpTypeVoid - %77 = OpTypeFunction %void - %82 = OpConstantNull %v2int + %75 = OpTypeFunction %void + %80 = OpConstantNull %v2int %_ptr_Function_v2int = OpTypePointer Function %v2int - %85 = OpTypeFunction %v4float + %83 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_count_leading_zeros = OpFunction %v2int None %9 %v = OpFunctionParameter %v2int @@ -76,68 +74,68 @@ OpStore %x %15 %22 = OpLoad %v2uint %x %25 = OpULessThanEqual %v2bool %22 %24 - %21 = OpSelect %v2uint %25 %29 %31 - %32 = OpLoad %v2uint %x - %33 = OpShiftLeftLogical %v2uint %32 %21 - OpStore %x %33 - %35 = OpLoad %v2uint %x - %38 = OpULessThanEqual %v2bool %35 %37 - %34 = OpSelect %v2uint %38 %40 %31 - %41 = OpLoad %v2uint %x - %42 = OpShiftLeftLogical %v2uint %41 %34 - OpStore %x %42 - %44 = OpLoad %v2uint %x - %47 = OpULessThanEqual %v2bool %44 %46 - %43 = OpSelect %v2uint %47 %49 %31 - %50 = OpLoad %v2uint %x - %51 = OpShiftLeftLogical %v2uint %50 %43 - OpStore %x %51 - %53 = OpLoad %v2uint %x - %56 = OpULessThanEqual %v2bool %53 %55 - %52 = OpSelect %v2uint %56 %58 %31 - %59 = OpLoad %v2uint %x - %60 = OpShiftLeftLogical %v2uint %59 %52 - OpStore %x %60 - %62 = OpLoad %v2uint %x - %65 = OpULessThanEqual %v2bool %62 %64 - %61 = OpSelect %v2uint %65 %67 %31 - %69 = OpLoad %v2uint %x - %70 = OpIEqual %v2bool %69 %31 - %68 = OpSelect %v2uint %70 %67 %31 - %72 = OpBitwiseOr %v2uint %21 %34 - %73 = OpBitwiseOr %v2uint %72 %43 - %74 = OpBitwiseOr %v2uint %73 %52 - %75 = OpBitwiseOr %v2uint %74 %61 - %76 = OpIAdd %v2uint %75 %68 - %71 = OpBitcast %v2int %76 - OpReturnValue %71 + %21 = OpSelect %v2uint %25 %29 %20 + %30 = OpLoad %v2uint %x + %31 = OpShiftLeftLogical %v2uint %30 %21 + OpStore %x %31 + %33 = OpLoad %v2uint %x + %36 = OpULessThanEqual %v2bool %33 %35 + %32 = OpSelect %v2uint %36 %38 %20 + %39 = OpLoad %v2uint %x + %40 = OpShiftLeftLogical %v2uint %39 %32 + OpStore %x %40 + %42 = OpLoad %v2uint %x + %45 = OpULessThanEqual %v2bool %42 %44 + %41 = OpSelect %v2uint %45 %47 %20 + %48 = OpLoad %v2uint %x + %49 = OpShiftLeftLogical %v2uint %48 %41 + OpStore %x %49 + %51 = OpLoad %v2uint %x + %54 = OpULessThanEqual %v2bool %51 %53 + %50 = OpSelect %v2uint %54 %56 %20 + %57 = OpLoad %v2uint %x + %58 = OpShiftLeftLogical %v2uint %57 %50 + OpStore %x %58 + %60 = OpLoad %v2uint %x + %63 = OpULessThanEqual %v2bool %60 %62 + %59 = OpSelect %v2uint %63 %65 %20 + %67 = OpLoad %v2uint %x + %68 = OpIEqual %v2bool %67 %20 + %66 = OpSelect %v2uint %68 %65 %20 + %70 = OpBitwiseOr %v2uint %21 %32 + %71 = OpBitwiseOr %v2uint %70 %41 + %72 = OpBitwiseOr %v2uint %71 %50 + %73 = OpBitwiseOr %v2uint %72 %59 + %74 = OpIAdd %v2uint %73 %66 + %69 = OpBitcast %v2int %74 + OpReturnValue %69 OpFunctionEnd -%countLeadingZeros_858d40 = OpFunction %void None %77 - %80 = OpLabel - %res = OpVariable %_ptr_Function_v2int Function %82 - %81 = OpFunctionCall %v2int %tint_count_leading_zeros %82 - OpStore %res %81 +%countLeadingZeros_858d40 = OpFunction %void None %75 + %78 = OpLabel + %res = OpVariable %_ptr_Function_v2int Function %80 + %79 = OpFunctionCall %v2int %tint_count_leading_zeros %80 + OpStore %res %79 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %85 - %87 = OpLabel - %88 = OpFunctionCall %void %countLeadingZeros_858d40 +%vertex_main_inner = OpFunction %v4float None %83 + %85 = OpLabel + %86 = OpFunctionCall %void %countLeadingZeros_858d40 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %77 - %90 = OpLabel - %91 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %91 +%vertex_main = OpFunction %void None %75 + %88 = OpLabel + %89 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %89 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %77 - %94 = OpLabel - %95 = OpFunctionCall %void %countLeadingZeros_858d40 +%fragment_main = OpFunction %void None %75 + %92 = OpLabel + %93 = OpFunctionCall %void %countLeadingZeros_858d40 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %77 - %97 = OpLabel - %98 = OpFunctionCall %void %countLeadingZeros_858d40 +%compute_main = OpFunction %void None %75 + %95 = OpLabel + %96 = OpFunctionCall %void %countLeadingZeros_858d40 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/countLeadingZeros/ab6345.wgsl.expected.spvasm b/test/tint/builtins/gen/countLeadingZeros/ab6345.wgsl.expected.spvasm index fab1ff6395..60b0dbd8c5 100644 --- a/test/tint/builtins/gen/countLeadingZeros/ab6345.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/countLeadingZeros/ab6345.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 95 +; Bound: 93 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -42,27 +42,25 @@ %v3bool = OpTypeVector %bool 3 %uint_16 = OpConstant %uint 16 %27 = OpConstantComposite %v3uint %uint_16 %uint_16 %uint_16 - %uint_0 = OpConstant %uint 0 - %29 = OpConstantComposite %v3uint %uint_0 %uint_0 %uint_0 %uint_16777215 = OpConstant %uint 16777215 - %35 = OpConstantComposite %v3uint %uint_16777215 %uint_16777215 %uint_16777215 + %33 = OpConstantComposite %v3uint %uint_16777215 %uint_16777215 %uint_16777215 %uint_8 = OpConstant %uint 8 - %38 = OpConstantComposite %v3uint %uint_8 %uint_8 %uint_8 + %36 = OpConstantComposite %v3uint %uint_8 %uint_8 %uint_8 %uint_268435455 = OpConstant %uint 268435455 - %44 = OpConstantComposite %v3uint %uint_268435455 %uint_268435455 %uint_268435455 + %42 = OpConstantComposite %v3uint %uint_268435455 %uint_268435455 %uint_268435455 %uint_4 = OpConstant %uint 4 - %47 = OpConstantComposite %v3uint %uint_4 %uint_4 %uint_4 + %45 = OpConstantComposite %v3uint %uint_4 %uint_4 %uint_4 %uint_1073741823 = OpConstant %uint 1073741823 - %53 = OpConstantComposite %v3uint %uint_1073741823 %uint_1073741823 %uint_1073741823 + %51 = OpConstantComposite %v3uint %uint_1073741823 %uint_1073741823 %uint_1073741823 %uint_2 = OpConstant %uint 2 - %56 = OpConstantComposite %v3uint %uint_2 %uint_2 %uint_2 + %54 = OpConstantComposite %v3uint %uint_2 %uint_2 %uint_2 %uint_2147483647 = OpConstant %uint 2147483647 - %62 = OpConstantComposite %v3uint %uint_2147483647 %uint_2147483647 %uint_2147483647 + %60 = OpConstantComposite %v3uint %uint_2147483647 %uint_2147483647 %uint_2147483647 %uint_1 = OpConstant %uint 1 - %65 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 + %63 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %void = OpTypeVoid - %75 = OpTypeFunction %void - %81 = OpTypeFunction %v4float + %73 = OpTypeFunction %void + %79 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_count_leading_zeros = OpFunction %v3uint None %9 %v = OpFunctionParameter %v3uint @@ -71,67 +69,67 @@ OpStore %x %v %20 = OpLoad %v3uint %x %23 = OpULessThanEqual %v3bool %20 %22 - %19 = OpSelect %v3uint %23 %27 %29 - %30 = OpLoad %v3uint %x - %31 = OpShiftLeftLogical %v3uint %30 %19 - OpStore %x %31 - %33 = OpLoad %v3uint %x - %36 = OpULessThanEqual %v3bool %33 %35 - %32 = OpSelect %v3uint %36 %38 %29 - %39 = OpLoad %v3uint %x - %40 = OpShiftLeftLogical %v3uint %39 %32 - OpStore %x %40 - %42 = OpLoad %v3uint %x - %45 = OpULessThanEqual %v3bool %42 %44 - %41 = OpSelect %v3uint %45 %47 %29 - %48 = OpLoad %v3uint %x - %49 = OpShiftLeftLogical %v3uint %48 %41 - OpStore %x %49 - %51 = OpLoad %v3uint %x - %54 = OpULessThanEqual %v3bool %51 %53 - %50 = OpSelect %v3uint %54 %56 %29 - %57 = OpLoad %v3uint %x - %58 = OpShiftLeftLogical %v3uint %57 %50 - OpStore %x %58 - %60 = OpLoad %v3uint %x - %63 = OpULessThanEqual %v3bool %60 %62 - %59 = OpSelect %v3uint %63 %65 %29 - %67 = OpLoad %v3uint %x - %68 = OpIEqual %v3bool %67 %29 - %66 = OpSelect %v3uint %68 %65 %29 - %70 = OpBitwiseOr %v3uint %19 %32 - %71 = OpBitwiseOr %v3uint %70 %41 - %72 = OpBitwiseOr %v3uint %71 %50 - %73 = OpBitwiseOr %v3uint %72 %59 - %74 = OpIAdd %v3uint %73 %66 - OpReturnValue %74 + %19 = OpSelect %v3uint %23 %27 %18 + %28 = OpLoad %v3uint %x + %29 = OpShiftLeftLogical %v3uint %28 %19 + OpStore %x %29 + %31 = OpLoad %v3uint %x + %34 = OpULessThanEqual %v3bool %31 %33 + %30 = OpSelect %v3uint %34 %36 %18 + %37 = OpLoad %v3uint %x + %38 = OpShiftLeftLogical %v3uint %37 %30 + OpStore %x %38 + %40 = OpLoad %v3uint %x + %43 = OpULessThanEqual %v3bool %40 %42 + %39 = OpSelect %v3uint %43 %45 %18 + %46 = OpLoad %v3uint %x + %47 = OpShiftLeftLogical %v3uint %46 %39 + OpStore %x %47 + %49 = OpLoad %v3uint %x + %52 = OpULessThanEqual %v3bool %49 %51 + %48 = OpSelect %v3uint %52 %54 %18 + %55 = OpLoad %v3uint %x + %56 = OpShiftLeftLogical %v3uint %55 %48 + OpStore %x %56 + %58 = OpLoad %v3uint %x + %61 = OpULessThanEqual %v3bool %58 %60 + %57 = OpSelect %v3uint %61 %63 %18 + %65 = OpLoad %v3uint %x + %66 = OpIEqual %v3bool %65 %18 + %64 = OpSelect %v3uint %66 %63 %18 + %68 = OpBitwiseOr %v3uint %19 %30 + %69 = OpBitwiseOr %v3uint %68 %39 + %70 = OpBitwiseOr %v3uint %69 %48 + %71 = OpBitwiseOr %v3uint %70 %57 + %72 = OpIAdd %v3uint %71 %64 + OpReturnValue %72 OpFunctionEnd -%countLeadingZeros_ab6345 = OpFunction %void None %75 - %78 = OpLabel +%countLeadingZeros_ab6345 = OpFunction %void None %73 + %76 = OpLabel %res = OpVariable %_ptr_Function_v3uint Function %18 - %79 = OpFunctionCall %v3uint %tint_count_leading_zeros %18 - OpStore %res %79 + %77 = OpFunctionCall %v3uint %tint_count_leading_zeros %18 + OpStore %res %77 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %81 - %83 = OpLabel - %84 = OpFunctionCall %void %countLeadingZeros_ab6345 +%vertex_main_inner = OpFunction %v4float None %79 + %81 = OpLabel + %82 = OpFunctionCall %void %countLeadingZeros_ab6345 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %75 - %86 = OpLabel - %87 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %87 +%vertex_main = OpFunction %void None %73 + %84 = OpLabel + %85 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %85 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %75 - %90 = OpLabel - %91 = OpFunctionCall %void %countLeadingZeros_ab6345 +%fragment_main = OpFunction %void None %73 + %88 = OpLabel + %89 = OpFunctionCall %void %countLeadingZeros_ab6345 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %75 - %93 = OpLabel - %94 = OpFunctionCall %void %countLeadingZeros_ab6345 +%compute_main = OpFunction %void None %73 + %91 = OpLabel + %92 = OpFunctionCall %void %countLeadingZeros_ab6345 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/countLeadingZeros/eab32b.wgsl.expected.spvasm b/test/tint/builtins/gen/countLeadingZeros/eab32b.wgsl.expected.spvasm index 6353f3d391..48b74acc76 100644 --- a/test/tint/builtins/gen/countLeadingZeros/eab32b.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/countLeadingZeros/eab32b.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 99 +; Bound: 97 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -44,29 +44,27 @@ %v4bool = OpTypeVector %bool 4 %uint_16 = OpConstant %uint 16 %29 = OpConstantComposite %v4uint %uint_16 %uint_16 %uint_16 %uint_16 - %uint_0 = OpConstant %uint 0 - %31 = OpConstantComposite %v4uint %uint_0 %uint_0 %uint_0 %uint_0 %uint_16777215 = OpConstant %uint 16777215 - %37 = OpConstantComposite %v4uint %uint_16777215 %uint_16777215 %uint_16777215 %uint_16777215 + %35 = OpConstantComposite %v4uint %uint_16777215 %uint_16777215 %uint_16777215 %uint_16777215 %uint_8 = OpConstant %uint 8 - %40 = OpConstantComposite %v4uint %uint_8 %uint_8 %uint_8 %uint_8 + %38 = OpConstantComposite %v4uint %uint_8 %uint_8 %uint_8 %uint_8 %uint_268435455 = OpConstant %uint 268435455 - %46 = OpConstantComposite %v4uint %uint_268435455 %uint_268435455 %uint_268435455 %uint_268435455 + %44 = OpConstantComposite %v4uint %uint_268435455 %uint_268435455 %uint_268435455 %uint_268435455 %uint_4 = OpConstant %uint 4 - %49 = OpConstantComposite %v4uint %uint_4 %uint_4 %uint_4 %uint_4 + %47 = OpConstantComposite %v4uint %uint_4 %uint_4 %uint_4 %uint_4 %uint_1073741823 = OpConstant %uint 1073741823 - %55 = OpConstantComposite %v4uint %uint_1073741823 %uint_1073741823 %uint_1073741823 %uint_1073741823 + %53 = OpConstantComposite %v4uint %uint_1073741823 %uint_1073741823 %uint_1073741823 %uint_1073741823 %uint_2 = OpConstant %uint 2 - %58 = OpConstantComposite %v4uint %uint_2 %uint_2 %uint_2 %uint_2 + %56 = OpConstantComposite %v4uint %uint_2 %uint_2 %uint_2 %uint_2 %uint_2147483647 = OpConstant %uint 2147483647 - %64 = OpConstantComposite %v4uint %uint_2147483647 %uint_2147483647 %uint_2147483647 %uint_2147483647 + %62 = OpConstantComposite %v4uint %uint_2147483647 %uint_2147483647 %uint_2147483647 %uint_2147483647 %uint_1 = OpConstant %uint 1 - %67 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 + %65 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 %void = OpTypeVoid - %77 = OpTypeFunction %void - %82 = OpConstantNull %v4int + %75 = OpTypeFunction %void + %80 = OpConstantNull %v4int %_ptr_Function_v4int = OpTypePointer Function %v4int - %85 = OpTypeFunction %v4float + %83 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_count_leading_zeros = OpFunction %v4int None %9 %v = OpFunctionParameter %v4int @@ -76,68 +74,68 @@ OpStore %x %15 %22 = OpLoad %v4uint %x %25 = OpULessThanEqual %v4bool %22 %24 - %21 = OpSelect %v4uint %25 %29 %31 - %32 = OpLoad %v4uint %x - %33 = OpShiftLeftLogical %v4uint %32 %21 - OpStore %x %33 - %35 = OpLoad %v4uint %x - %38 = OpULessThanEqual %v4bool %35 %37 - %34 = OpSelect %v4uint %38 %40 %31 - %41 = OpLoad %v4uint %x - %42 = OpShiftLeftLogical %v4uint %41 %34 - OpStore %x %42 - %44 = OpLoad %v4uint %x - %47 = OpULessThanEqual %v4bool %44 %46 - %43 = OpSelect %v4uint %47 %49 %31 - %50 = OpLoad %v4uint %x - %51 = OpShiftLeftLogical %v4uint %50 %43 - OpStore %x %51 - %53 = OpLoad %v4uint %x - %56 = OpULessThanEqual %v4bool %53 %55 - %52 = OpSelect %v4uint %56 %58 %31 - %59 = OpLoad %v4uint %x - %60 = OpShiftLeftLogical %v4uint %59 %52 - OpStore %x %60 - %62 = OpLoad %v4uint %x - %65 = OpULessThanEqual %v4bool %62 %64 - %61 = OpSelect %v4uint %65 %67 %31 - %69 = OpLoad %v4uint %x - %70 = OpIEqual %v4bool %69 %31 - %68 = OpSelect %v4uint %70 %67 %31 - %72 = OpBitwiseOr %v4uint %21 %34 - %73 = OpBitwiseOr %v4uint %72 %43 - %74 = OpBitwiseOr %v4uint %73 %52 - %75 = OpBitwiseOr %v4uint %74 %61 - %76 = OpIAdd %v4uint %75 %68 - %71 = OpBitcast %v4int %76 - OpReturnValue %71 + %21 = OpSelect %v4uint %25 %29 %20 + %30 = OpLoad %v4uint %x + %31 = OpShiftLeftLogical %v4uint %30 %21 + OpStore %x %31 + %33 = OpLoad %v4uint %x + %36 = OpULessThanEqual %v4bool %33 %35 + %32 = OpSelect %v4uint %36 %38 %20 + %39 = OpLoad %v4uint %x + %40 = OpShiftLeftLogical %v4uint %39 %32 + OpStore %x %40 + %42 = OpLoad %v4uint %x + %45 = OpULessThanEqual %v4bool %42 %44 + %41 = OpSelect %v4uint %45 %47 %20 + %48 = OpLoad %v4uint %x + %49 = OpShiftLeftLogical %v4uint %48 %41 + OpStore %x %49 + %51 = OpLoad %v4uint %x + %54 = OpULessThanEqual %v4bool %51 %53 + %50 = OpSelect %v4uint %54 %56 %20 + %57 = OpLoad %v4uint %x + %58 = OpShiftLeftLogical %v4uint %57 %50 + OpStore %x %58 + %60 = OpLoad %v4uint %x + %63 = OpULessThanEqual %v4bool %60 %62 + %59 = OpSelect %v4uint %63 %65 %20 + %67 = OpLoad %v4uint %x + %68 = OpIEqual %v4bool %67 %20 + %66 = OpSelect %v4uint %68 %65 %20 + %70 = OpBitwiseOr %v4uint %21 %32 + %71 = OpBitwiseOr %v4uint %70 %41 + %72 = OpBitwiseOr %v4uint %71 %50 + %73 = OpBitwiseOr %v4uint %72 %59 + %74 = OpIAdd %v4uint %73 %66 + %69 = OpBitcast %v4int %74 + OpReturnValue %69 OpFunctionEnd -%countLeadingZeros_eab32b = OpFunction %void None %77 - %80 = OpLabel - %res = OpVariable %_ptr_Function_v4int Function %82 - %81 = OpFunctionCall %v4int %tint_count_leading_zeros %82 - OpStore %res %81 +%countLeadingZeros_eab32b = OpFunction %void None %75 + %78 = OpLabel + %res = OpVariable %_ptr_Function_v4int Function %80 + %79 = OpFunctionCall %v4int %tint_count_leading_zeros %80 + OpStore %res %79 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %85 - %87 = OpLabel - %88 = OpFunctionCall %void %countLeadingZeros_eab32b +%vertex_main_inner = OpFunction %v4float None %83 + %85 = OpLabel + %86 = OpFunctionCall %void %countLeadingZeros_eab32b OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %77 - %90 = OpLabel - %91 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %91 +%vertex_main = OpFunction %void None %75 + %88 = OpLabel + %89 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %89 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %77 - %94 = OpLabel - %95 = OpFunctionCall %void %countLeadingZeros_eab32b +%fragment_main = OpFunction %void None %75 + %92 = OpLabel + %93 = OpFunctionCall %void %countLeadingZeros_eab32b OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %77 - %97 = OpLabel - %98 = OpFunctionCall %void %countLeadingZeros_eab32b +%compute_main = OpFunction %void None %75 + %95 = OpLabel + %96 = OpFunctionCall %void %countLeadingZeros_eab32b OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/countLeadingZeros/f70103.wgsl.expected.spvasm b/test/tint/builtins/gen/countLeadingZeros/f70103.wgsl.expected.spvasm index 34be5df063..4a96690ccf 100644 --- a/test/tint/builtins/gen/countLeadingZeros/f70103.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/countLeadingZeros/f70103.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 95 +; Bound: 93 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -42,27 +42,25 @@ %v4bool = OpTypeVector %bool 4 %uint_16 = OpConstant %uint 16 %27 = OpConstantComposite %v4uint %uint_16 %uint_16 %uint_16 %uint_16 - %uint_0 = OpConstant %uint 0 - %29 = OpConstantComposite %v4uint %uint_0 %uint_0 %uint_0 %uint_0 %uint_16777215 = OpConstant %uint 16777215 - %35 = OpConstantComposite %v4uint %uint_16777215 %uint_16777215 %uint_16777215 %uint_16777215 + %33 = OpConstantComposite %v4uint %uint_16777215 %uint_16777215 %uint_16777215 %uint_16777215 %uint_8 = OpConstant %uint 8 - %38 = OpConstantComposite %v4uint %uint_8 %uint_8 %uint_8 %uint_8 + %36 = OpConstantComposite %v4uint %uint_8 %uint_8 %uint_8 %uint_8 %uint_268435455 = OpConstant %uint 268435455 - %44 = OpConstantComposite %v4uint %uint_268435455 %uint_268435455 %uint_268435455 %uint_268435455 + %42 = OpConstantComposite %v4uint %uint_268435455 %uint_268435455 %uint_268435455 %uint_268435455 %uint_4 = OpConstant %uint 4 - %47 = OpConstantComposite %v4uint %uint_4 %uint_4 %uint_4 %uint_4 + %45 = OpConstantComposite %v4uint %uint_4 %uint_4 %uint_4 %uint_4 %uint_1073741823 = OpConstant %uint 1073741823 - %53 = OpConstantComposite %v4uint %uint_1073741823 %uint_1073741823 %uint_1073741823 %uint_1073741823 + %51 = OpConstantComposite %v4uint %uint_1073741823 %uint_1073741823 %uint_1073741823 %uint_1073741823 %uint_2 = OpConstant %uint 2 - %56 = OpConstantComposite %v4uint %uint_2 %uint_2 %uint_2 %uint_2 + %54 = OpConstantComposite %v4uint %uint_2 %uint_2 %uint_2 %uint_2 %uint_2147483647 = OpConstant %uint 2147483647 - %62 = OpConstantComposite %v4uint %uint_2147483647 %uint_2147483647 %uint_2147483647 %uint_2147483647 + %60 = OpConstantComposite %v4uint %uint_2147483647 %uint_2147483647 %uint_2147483647 %uint_2147483647 %uint_1 = OpConstant %uint 1 - %65 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 + %63 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 %void = OpTypeVoid - %75 = OpTypeFunction %void - %81 = OpTypeFunction %v4float + %73 = OpTypeFunction %void + %79 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_count_leading_zeros = OpFunction %v4uint None %9 %v = OpFunctionParameter %v4uint @@ -71,67 +69,67 @@ OpStore %x %v %20 = OpLoad %v4uint %x %23 = OpULessThanEqual %v4bool %20 %22 - %19 = OpSelect %v4uint %23 %27 %29 - %30 = OpLoad %v4uint %x - %31 = OpShiftLeftLogical %v4uint %30 %19 - OpStore %x %31 - %33 = OpLoad %v4uint %x - %36 = OpULessThanEqual %v4bool %33 %35 - %32 = OpSelect %v4uint %36 %38 %29 - %39 = OpLoad %v4uint %x - %40 = OpShiftLeftLogical %v4uint %39 %32 - OpStore %x %40 - %42 = OpLoad %v4uint %x - %45 = OpULessThanEqual %v4bool %42 %44 - %41 = OpSelect %v4uint %45 %47 %29 - %48 = OpLoad %v4uint %x - %49 = OpShiftLeftLogical %v4uint %48 %41 - OpStore %x %49 - %51 = OpLoad %v4uint %x - %54 = OpULessThanEqual %v4bool %51 %53 - %50 = OpSelect %v4uint %54 %56 %29 - %57 = OpLoad %v4uint %x - %58 = OpShiftLeftLogical %v4uint %57 %50 - OpStore %x %58 - %60 = OpLoad %v4uint %x - %63 = OpULessThanEqual %v4bool %60 %62 - %59 = OpSelect %v4uint %63 %65 %29 - %67 = OpLoad %v4uint %x - %68 = OpIEqual %v4bool %67 %29 - %66 = OpSelect %v4uint %68 %65 %29 - %70 = OpBitwiseOr %v4uint %19 %32 - %71 = OpBitwiseOr %v4uint %70 %41 - %72 = OpBitwiseOr %v4uint %71 %50 - %73 = OpBitwiseOr %v4uint %72 %59 - %74 = OpIAdd %v4uint %73 %66 - OpReturnValue %74 + %19 = OpSelect %v4uint %23 %27 %18 + %28 = OpLoad %v4uint %x + %29 = OpShiftLeftLogical %v4uint %28 %19 + OpStore %x %29 + %31 = OpLoad %v4uint %x + %34 = OpULessThanEqual %v4bool %31 %33 + %30 = OpSelect %v4uint %34 %36 %18 + %37 = OpLoad %v4uint %x + %38 = OpShiftLeftLogical %v4uint %37 %30 + OpStore %x %38 + %40 = OpLoad %v4uint %x + %43 = OpULessThanEqual %v4bool %40 %42 + %39 = OpSelect %v4uint %43 %45 %18 + %46 = OpLoad %v4uint %x + %47 = OpShiftLeftLogical %v4uint %46 %39 + OpStore %x %47 + %49 = OpLoad %v4uint %x + %52 = OpULessThanEqual %v4bool %49 %51 + %48 = OpSelect %v4uint %52 %54 %18 + %55 = OpLoad %v4uint %x + %56 = OpShiftLeftLogical %v4uint %55 %48 + OpStore %x %56 + %58 = OpLoad %v4uint %x + %61 = OpULessThanEqual %v4bool %58 %60 + %57 = OpSelect %v4uint %61 %63 %18 + %65 = OpLoad %v4uint %x + %66 = OpIEqual %v4bool %65 %18 + %64 = OpSelect %v4uint %66 %63 %18 + %68 = OpBitwiseOr %v4uint %19 %30 + %69 = OpBitwiseOr %v4uint %68 %39 + %70 = OpBitwiseOr %v4uint %69 %48 + %71 = OpBitwiseOr %v4uint %70 %57 + %72 = OpIAdd %v4uint %71 %64 + OpReturnValue %72 OpFunctionEnd -%countLeadingZeros_f70103 = OpFunction %void None %75 - %78 = OpLabel +%countLeadingZeros_f70103 = OpFunction %void None %73 + %76 = OpLabel %res = OpVariable %_ptr_Function_v4uint Function %18 - %79 = OpFunctionCall %v4uint %tint_count_leading_zeros %18 - OpStore %res %79 + %77 = OpFunctionCall %v4uint %tint_count_leading_zeros %18 + OpStore %res %77 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %81 - %83 = OpLabel - %84 = OpFunctionCall %void %countLeadingZeros_f70103 +%vertex_main_inner = OpFunction %v4float None %79 + %81 = OpLabel + %82 = OpFunctionCall %void %countLeadingZeros_f70103 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %75 - %86 = OpLabel - %87 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %87 +%vertex_main = OpFunction %void None %73 + %84 = OpLabel + %85 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %85 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %75 - %90 = OpLabel - %91 = OpFunctionCall %void %countLeadingZeros_f70103 +%fragment_main = OpFunction %void None %73 + %88 = OpLabel + %89 = OpFunctionCall %void %countLeadingZeros_f70103 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %75 - %93 = OpLabel - %94 = OpFunctionCall %void %countLeadingZeros_f70103 +%compute_main = OpFunction %void None %73 + %91 = OpLabel + %92 = OpFunctionCall %void %countLeadingZeros_f70103 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/countTrailingZeros/1ad138.wgsl.expected.spvasm b/test/tint/builtins/gen/countTrailingZeros/1ad138.wgsl.expected.spvasm index 96849eff1c..76c89217ca 100644 --- a/test/tint/builtins/gen/countTrailingZeros/1ad138.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/countTrailingZeros/1ad138.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 98 +; Bound: 96 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -40,27 +40,25 @@ %v2bool = OpTypeVector %bool 2 %uint_65535 = OpConstant %uint 65535 %25 = OpConstantComposite %v2uint %uint_65535 %uint_65535 - %uint_0 = OpConstant %uint 0 - %28 = OpConstantComposite %v2uint %uint_0 %uint_0 %uint_16 = OpConstant %uint 16 - %30 = OpConstantComposite %v2uint %uint_16 %uint_16 + %28 = OpConstantComposite %v2uint %uint_16 %uint_16 %uint_255 = OpConstant %uint 255 - %37 = OpConstantComposite %v2uint %uint_255 %uint_255 + %35 = OpConstantComposite %v2uint %uint_255 %uint_255 %uint_8 = OpConstant %uint 8 - %40 = OpConstantComposite %v2uint %uint_8 %uint_8 + %38 = OpConstantComposite %v2uint %uint_8 %uint_8 %uint_15 = OpConstant %uint 15 - %47 = OpConstantComposite %v2uint %uint_15 %uint_15 + %45 = OpConstantComposite %v2uint %uint_15 %uint_15 %uint_4 = OpConstant %uint 4 - %50 = OpConstantComposite %v2uint %uint_4 %uint_4 + %48 = OpConstantComposite %v2uint %uint_4 %uint_4 %uint_3 = OpConstant %uint 3 - %57 = OpConstantComposite %v2uint %uint_3 %uint_3 + %55 = OpConstantComposite %v2uint %uint_3 %uint_3 %uint_2 = OpConstant %uint 2 - %60 = OpConstantComposite %v2uint %uint_2 %uint_2 + %58 = OpConstantComposite %v2uint %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %67 = OpConstantComposite %v2uint %uint_1 %uint_1 + %65 = OpConstantComposite %v2uint %uint_1 %uint_1 %void = OpTypeVoid - %78 = OpTypeFunction %void - %84 = OpTypeFunction %v4float + %76 = OpTypeFunction %void + %82 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_count_trailing_zeros = OpFunction %v2uint None %9 %v = OpFunctionParameter %v2uint @@ -70,71 +68,71 @@ %23 = OpLoad %v2uint %x %26 = OpBitwiseAnd %v2uint %23 %25 %20 = OpINotEqual %v2bool %26 %18 - %19 = OpSelect %v2uint %20 %28 %30 - %31 = OpLoad %v2uint %x - %32 = OpShiftRightLogical %v2uint %31 %19 - OpStore %x %32 - %35 = OpLoad %v2uint %x - %38 = OpBitwiseAnd %v2uint %35 %37 - %34 = OpINotEqual %v2bool %38 %18 - %33 = OpSelect %v2uint %34 %28 %40 - %41 = OpLoad %v2uint %x - %42 = OpShiftRightLogical %v2uint %41 %33 - OpStore %x %42 - %45 = OpLoad %v2uint %x - %48 = OpBitwiseAnd %v2uint %45 %47 - %44 = OpINotEqual %v2bool %48 %18 - %43 = OpSelect %v2uint %44 %28 %50 - %51 = OpLoad %v2uint %x - %52 = OpShiftRightLogical %v2uint %51 %43 - OpStore %x %52 - %55 = OpLoad %v2uint %x - %58 = OpBitwiseAnd %v2uint %55 %57 - %54 = OpINotEqual %v2bool %58 %18 - %53 = OpSelect %v2uint %54 %28 %60 - %61 = OpLoad %v2uint %x - %62 = OpShiftRightLogical %v2uint %61 %53 - OpStore %x %62 - %65 = OpLoad %v2uint %x - %68 = OpBitwiseAnd %v2uint %65 %67 - %64 = OpINotEqual %v2bool %68 %18 - %63 = OpSelect %v2uint %64 %28 %67 - %70 = OpLoad %v2uint %x - %71 = OpIEqual %v2bool %70 %28 - %69 = OpSelect %v2uint %71 %67 %28 - %73 = OpBitwiseOr %v2uint %19 %33 - %74 = OpBitwiseOr %v2uint %73 %43 - %75 = OpBitwiseOr %v2uint %74 %53 - %76 = OpBitwiseOr %v2uint %75 %63 - %77 = OpIAdd %v2uint %76 %69 - OpReturnValue %77 + %19 = OpSelect %v2uint %20 %18 %28 + %29 = OpLoad %v2uint %x + %30 = OpShiftRightLogical %v2uint %29 %19 + OpStore %x %30 + %33 = OpLoad %v2uint %x + %36 = OpBitwiseAnd %v2uint %33 %35 + %32 = OpINotEqual %v2bool %36 %18 + %31 = OpSelect %v2uint %32 %18 %38 + %39 = OpLoad %v2uint %x + %40 = OpShiftRightLogical %v2uint %39 %31 + OpStore %x %40 + %43 = OpLoad %v2uint %x + %46 = OpBitwiseAnd %v2uint %43 %45 + %42 = OpINotEqual %v2bool %46 %18 + %41 = OpSelect %v2uint %42 %18 %48 + %49 = OpLoad %v2uint %x + %50 = OpShiftRightLogical %v2uint %49 %41 + OpStore %x %50 + %53 = OpLoad %v2uint %x + %56 = OpBitwiseAnd %v2uint %53 %55 + %52 = OpINotEqual %v2bool %56 %18 + %51 = OpSelect %v2uint %52 %18 %58 + %59 = OpLoad %v2uint %x + %60 = OpShiftRightLogical %v2uint %59 %51 + OpStore %x %60 + %63 = OpLoad %v2uint %x + %66 = OpBitwiseAnd %v2uint %63 %65 + %62 = OpINotEqual %v2bool %66 %18 + %61 = OpSelect %v2uint %62 %18 %65 + %68 = OpLoad %v2uint %x + %69 = OpIEqual %v2bool %68 %18 + %67 = OpSelect %v2uint %69 %65 %18 + %71 = OpBitwiseOr %v2uint %19 %31 + %72 = OpBitwiseOr %v2uint %71 %41 + %73 = OpBitwiseOr %v2uint %72 %51 + %74 = OpBitwiseOr %v2uint %73 %61 + %75 = OpIAdd %v2uint %74 %67 + OpReturnValue %75 OpFunctionEnd -%countTrailingZeros_1ad138 = OpFunction %void None %78 - %81 = OpLabel +%countTrailingZeros_1ad138 = OpFunction %void None %76 + %79 = OpLabel %res = OpVariable %_ptr_Function_v2uint Function %18 - %82 = OpFunctionCall %v2uint %tint_count_trailing_zeros %18 - OpStore %res %82 + %80 = OpFunctionCall %v2uint %tint_count_trailing_zeros %18 + OpStore %res %80 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %84 - %86 = OpLabel - %87 = OpFunctionCall %void %countTrailingZeros_1ad138 +%vertex_main_inner = OpFunction %v4float None %82 + %84 = OpLabel + %85 = OpFunctionCall %void %countTrailingZeros_1ad138 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %78 - %89 = OpLabel - %90 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %90 +%vertex_main = OpFunction %void None %76 + %87 = OpLabel + %88 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %88 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %78 - %93 = OpLabel - %94 = OpFunctionCall %void %countTrailingZeros_1ad138 +%fragment_main = OpFunction %void None %76 + %91 = OpLabel + %92 = OpFunctionCall %void %countTrailingZeros_1ad138 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %78 - %96 = OpLabel - %97 = OpFunctionCall %void %countTrailingZeros_1ad138 +%compute_main = OpFunction %void None %76 + %94 = OpLabel + %95 = OpFunctionCall %void %countTrailingZeros_1ad138 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/countTrailingZeros/1dc84a.wgsl.expected.spvasm b/test/tint/builtins/gen/countTrailingZeros/1dc84a.wgsl.expected.spvasm index dfc1ee712f..2987af583d 100644 --- a/test/tint/builtins/gen/countTrailingZeros/1dc84a.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/countTrailingZeros/1dc84a.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 102 +; Bound: 100 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -42,29 +42,27 @@ %v4bool = OpTypeVector %bool 4 %uint_65535 = OpConstant %uint 65535 %27 = OpConstantComposite %v4uint %uint_65535 %uint_65535 %uint_65535 %uint_65535 - %uint_0 = OpConstant %uint 0 - %30 = OpConstantComposite %v4uint %uint_0 %uint_0 %uint_0 %uint_0 %uint_16 = OpConstant %uint 16 - %32 = OpConstantComposite %v4uint %uint_16 %uint_16 %uint_16 %uint_16 + %30 = OpConstantComposite %v4uint %uint_16 %uint_16 %uint_16 %uint_16 %uint_255 = OpConstant %uint 255 - %39 = OpConstantComposite %v4uint %uint_255 %uint_255 %uint_255 %uint_255 + %37 = OpConstantComposite %v4uint %uint_255 %uint_255 %uint_255 %uint_255 %uint_8 = OpConstant %uint 8 - %42 = OpConstantComposite %v4uint %uint_8 %uint_8 %uint_8 %uint_8 + %40 = OpConstantComposite %v4uint %uint_8 %uint_8 %uint_8 %uint_8 %uint_15 = OpConstant %uint 15 - %49 = OpConstantComposite %v4uint %uint_15 %uint_15 %uint_15 %uint_15 + %47 = OpConstantComposite %v4uint %uint_15 %uint_15 %uint_15 %uint_15 %uint_4 = OpConstant %uint 4 - %52 = OpConstantComposite %v4uint %uint_4 %uint_4 %uint_4 %uint_4 + %50 = OpConstantComposite %v4uint %uint_4 %uint_4 %uint_4 %uint_4 %uint_3 = OpConstant %uint 3 - %59 = OpConstantComposite %v4uint %uint_3 %uint_3 %uint_3 %uint_3 + %57 = OpConstantComposite %v4uint %uint_3 %uint_3 %uint_3 %uint_3 %uint_2 = OpConstant %uint 2 - %62 = OpConstantComposite %v4uint %uint_2 %uint_2 %uint_2 %uint_2 + %60 = OpConstantComposite %v4uint %uint_2 %uint_2 %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %69 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 + %67 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 %void = OpTypeVoid - %80 = OpTypeFunction %void - %85 = OpConstantNull %v4int + %78 = OpTypeFunction %void + %83 = OpConstantNull %v4int %_ptr_Function_v4int = OpTypePointer Function %v4int - %88 = OpTypeFunction %v4float + %86 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_count_trailing_zeros = OpFunction %v4int None %9 %v = OpFunctionParameter %v4int @@ -75,72 +73,72 @@ %25 = OpLoad %v4uint %x %28 = OpBitwiseAnd %v4uint %25 %27 %22 = OpINotEqual %v4bool %28 %20 - %21 = OpSelect %v4uint %22 %30 %32 - %33 = OpLoad %v4uint %x - %34 = OpShiftRightLogical %v4uint %33 %21 - OpStore %x %34 - %37 = OpLoad %v4uint %x - %40 = OpBitwiseAnd %v4uint %37 %39 - %36 = OpINotEqual %v4bool %40 %20 - %35 = OpSelect %v4uint %36 %30 %42 - %43 = OpLoad %v4uint %x - %44 = OpShiftRightLogical %v4uint %43 %35 - OpStore %x %44 - %47 = OpLoad %v4uint %x - %50 = OpBitwiseAnd %v4uint %47 %49 - %46 = OpINotEqual %v4bool %50 %20 - %45 = OpSelect %v4uint %46 %30 %52 - %53 = OpLoad %v4uint %x - %54 = OpShiftRightLogical %v4uint %53 %45 - OpStore %x %54 - %57 = OpLoad %v4uint %x - %60 = OpBitwiseAnd %v4uint %57 %59 - %56 = OpINotEqual %v4bool %60 %20 - %55 = OpSelect %v4uint %56 %30 %62 - %63 = OpLoad %v4uint %x - %64 = OpShiftRightLogical %v4uint %63 %55 - OpStore %x %64 - %67 = OpLoad %v4uint %x - %70 = OpBitwiseAnd %v4uint %67 %69 - %66 = OpINotEqual %v4bool %70 %20 - %65 = OpSelect %v4uint %66 %30 %69 - %72 = OpLoad %v4uint %x - %73 = OpIEqual %v4bool %72 %30 - %71 = OpSelect %v4uint %73 %69 %30 - %75 = OpBitwiseOr %v4uint %21 %35 - %76 = OpBitwiseOr %v4uint %75 %45 - %77 = OpBitwiseOr %v4uint %76 %55 - %78 = OpBitwiseOr %v4uint %77 %65 - %79 = OpIAdd %v4uint %78 %71 - %74 = OpBitcast %v4int %79 - OpReturnValue %74 + %21 = OpSelect %v4uint %22 %20 %30 + %31 = OpLoad %v4uint %x + %32 = OpShiftRightLogical %v4uint %31 %21 + OpStore %x %32 + %35 = OpLoad %v4uint %x + %38 = OpBitwiseAnd %v4uint %35 %37 + %34 = OpINotEqual %v4bool %38 %20 + %33 = OpSelect %v4uint %34 %20 %40 + %41 = OpLoad %v4uint %x + %42 = OpShiftRightLogical %v4uint %41 %33 + OpStore %x %42 + %45 = OpLoad %v4uint %x + %48 = OpBitwiseAnd %v4uint %45 %47 + %44 = OpINotEqual %v4bool %48 %20 + %43 = OpSelect %v4uint %44 %20 %50 + %51 = OpLoad %v4uint %x + %52 = OpShiftRightLogical %v4uint %51 %43 + OpStore %x %52 + %55 = OpLoad %v4uint %x + %58 = OpBitwiseAnd %v4uint %55 %57 + %54 = OpINotEqual %v4bool %58 %20 + %53 = OpSelect %v4uint %54 %20 %60 + %61 = OpLoad %v4uint %x + %62 = OpShiftRightLogical %v4uint %61 %53 + OpStore %x %62 + %65 = OpLoad %v4uint %x + %68 = OpBitwiseAnd %v4uint %65 %67 + %64 = OpINotEqual %v4bool %68 %20 + %63 = OpSelect %v4uint %64 %20 %67 + %70 = OpLoad %v4uint %x + %71 = OpIEqual %v4bool %70 %20 + %69 = OpSelect %v4uint %71 %67 %20 + %73 = OpBitwiseOr %v4uint %21 %33 + %74 = OpBitwiseOr %v4uint %73 %43 + %75 = OpBitwiseOr %v4uint %74 %53 + %76 = OpBitwiseOr %v4uint %75 %63 + %77 = OpIAdd %v4uint %76 %69 + %72 = OpBitcast %v4int %77 + OpReturnValue %72 OpFunctionEnd -%countTrailingZeros_1dc84a = OpFunction %void None %80 - %83 = OpLabel - %res = OpVariable %_ptr_Function_v4int Function %85 - %84 = OpFunctionCall %v4int %tint_count_trailing_zeros %85 - OpStore %res %84 +%countTrailingZeros_1dc84a = OpFunction %void None %78 + %81 = OpLabel + %res = OpVariable %_ptr_Function_v4int Function %83 + %82 = OpFunctionCall %v4int %tint_count_trailing_zeros %83 + OpStore %res %82 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %88 - %90 = OpLabel - %91 = OpFunctionCall %void %countTrailingZeros_1dc84a +%vertex_main_inner = OpFunction %v4float None %86 + %88 = OpLabel + %89 = OpFunctionCall %void %countTrailingZeros_1dc84a OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %80 - %93 = OpLabel - %94 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %94 +%vertex_main = OpFunction %void None %78 + %91 = OpLabel + %92 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %92 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %80 - %97 = OpLabel - %98 = OpFunctionCall %void %countTrailingZeros_1dc84a +%fragment_main = OpFunction %void None %78 + %95 = OpLabel + %96 = OpFunctionCall %void %countTrailingZeros_1dc84a OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %80 - %100 = OpLabel - %101 = OpFunctionCall %void %countTrailingZeros_1dc84a +%compute_main = OpFunction %void None %78 + %98 = OpLabel + %99 = OpFunctionCall %void %countTrailingZeros_1dc84a OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/countTrailingZeros/21e394.wgsl.expected.spvasm b/test/tint/builtins/gen/countTrailingZeros/21e394.wgsl.expected.spvasm index 3d313b6858..4d07aef584 100644 --- a/test/tint/builtins/gen/countTrailingZeros/21e394.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/countTrailingZeros/21e394.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 86 +; Bound: 85 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -37,7 +37,6 @@ %17 = OpConstantNull %uint %bool = OpTypeBool %uint_65535 = OpConstant %uint 65535 - %uint_0 = OpConstant %uint 0 %uint_16 = OpConstant %uint 16 %uint_255 = OpConstant %uint 255 %uint_8 = OpConstant %uint 8 @@ -47,8 +46,8 @@ %uint_2 = OpConstant %uint 2 %uint_1 = OpConstant %uint 1 %void = OpTypeVoid - %66 = OpTypeFunction %void - %72 = OpTypeFunction %v4float + %65 = OpTypeFunction %void + %71 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_count_trailing_zeros = OpFunction %uint None %9 %v = OpFunctionParameter %uint @@ -58,71 +57,71 @@ %21 = OpLoad %uint %x %23 = OpBitwiseAnd %uint %21 %uint_65535 %19 = OpINotEqual %bool %23 %17 - %18 = OpSelect %uint %19 %uint_0 %uint_16 - %26 = OpLoad %uint %x - %27 = OpShiftRightLogical %uint %26 %18 - OpStore %x %27 - %30 = OpLoad %uint %x - %32 = OpBitwiseAnd %uint %30 %uint_255 - %29 = OpINotEqual %bool %32 %17 - %28 = OpSelect %uint %29 %uint_0 %uint_8 - %34 = OpLoad %uint %x - %35 = OpShiftRightLogical %uint %34 %28 - OpStore %x %35 - %38 = OpLoad %uint %x - %40 = OpBitwiseAnd %uint %38 %uint_15 - %37 = OpINotEqual %bool %40 %17 - %36 = OpSelect %uint %37 %uint_0 %uint_4 - %42 = OpLoad %uint %x - %43 = OpShiftRightLogical %uint %42 %36 - OpStore %x %43 - %46 = OpLoad %uint %x - %48 = OpBitwiseAnd %uint %46 %uint_3 - %45 = OpINotEqual %bool %48 %17 - %44 = OpSelect %uint %45 %uint_0 %uint_2 - %50 = OpLoad %uint %x - %51 = OpShiftRightLogical %uint %50 %44 - OpStore %x %51 - %54 = OpLoad %uint %x - %56 = OpBitwiseAnd %uint %54 %uint_1 - %53 = OpINotEqual %bool %56 %17 - %52 = OpSelect %uint %53 %uint_0 %uint_1 - %58 = OpLoad %uint %x - %59 = OpIEqual %bool %58 %uint_0 - %57 = OpSelect %uint %59 %uint_1 %uint_0 - %61 = OpBitwiseOr %uint %18 %28 - %62 = OpBitwiseOr %uint %61 %36 - %63 = OpBitwiseOr %uint %62 %44 - %64 = OpBitwiseOr %uint %63 %52 - %65 = OpIAdd %uint %64 %57 - OpReturnValue %65 + %18 = OpSelect %uint %19 %17 %uint_16 + %25 = OpLoad %uint %x + %26 = OpShiftRightLogical %uint %25 %18 + OpStore %x %26 + %29 = OpLoad %uint %x + %31 = OpBitwiseAnd %uint %29 %uint_255 + %28 = OpINotEqual %bool %31 %17 + %27 = OpSelect %uint %28 %17 %uint_8 + %33 = OpLoad %uint %x + %34 = OpShiftRightLogical %uint %33 %27 + OpStore %x %34 + %37 = OpLoad %uint %x + %39 = OpBitwiseAnd %uint %37 %uint_15 + %36 = OpINotEqual %bool %39 %17 + %35 = OpSelect %uint %36 %17 %uint_4 + %41 = OpLoad %uint %x + %42 = OpShiftRightLogical %uint %41 %35 + OpStore %x %42 + %45 = OpLoad %uint %x + %47 = OpBitwiseAnd %uint %45 %uint_3 + %44 = OpINotEqual %bool %47 %17 + %43 = OpSelect %uint %44 %17 %uint_2 + %49 = OpLoad %uint %x + %50 = OpShiftRightLogical %uint %49 %43 + OpStore %x %50 + %53 = OpLoad %uint %x + %55 = OpBitwiseAnd %uint %53 %uint_1 + %52 = OpINotEqual %bool %55 %17 + %51 = OpSelect %uint %52 %17 %uint_1 + %57 = OpLoad %uint %x + %58 = OpIEqual %bool %57 %17 + %56 = OpSelect %uint %58 %uint_1 %17 + %60 = OpBitwiseOr %uint %18 %27 + %61 = OpBitwiseOr %uint %60 %35 + %62 = OpBitwiseOr %uint %61 %43 + %63 = OpBitwiseOr %uint %62 %51 + %64 = OpIAdd %uint %63 %56 + OpReturnValue %64 OpFunctionEnd -%countTrailingZeros_21e394 = OpFunction %void None %66 - %69 = OpLabel +%countTrailingZeros_21e394 = OpFunction %void None %65 + %68 = OpLabel %res = OpVariable %_ptr_Function_uint Function %17 - %70 = OpFunctionCall %uint %tint_count_trailing_zeros %uint_1 - OpStore %res %70 + %69 = OpFunctionCall %uint %tint_count_trailing_zeros %uint_1 + OpStore %res %69 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %72 - %74 = OpLabel - %75 = OpFunctionCall %void %countTrailingZeros_21e394 +%vertex_main_inner = OpFunction %v4float None %71 + %73 = OpLabel + %74 = OpFunctionCall %void %countTrailingZeros_21e394 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %66 - %77 = OpLabel - %78 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %78 +%vertex_main = OpFunction %void None %65 + %76 = OpLabel + %77 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %77 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %66 - %81 = OpLabel - %82 = OpFunctionCall %void %countTrailingZeros_21e394 +%fragment_main = OpFunction %void None %65 + %80 = OpLabel + %81 = OpFunctionCall %void %countTrailingZeros_21e394 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %66 - %84 = OpLabel - %85 = OpFunctionCall %void %countTrailingZeros_21e394 +%compute_main = OpFunction %void None %65 + %83 = OpLabel + %84 = OpFunctionCall %void %countTrailingZeros_21e394 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/countTrailingZeros/327c37.wgsl.expected.spvasm b/test/tint/builtins/gen/countTrailingZeros/327c37.wgsl.expected.spvasm index ddd198690a..46be26fb92 100644 --- a/test/tint/builtins/gen/countTrailingZeros/327c37.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/countTrailingZeros/327c37.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 102 +; Bound: 100 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -42,29 +42,27 @@ %v2bool = OpTypeVector %bool 2 %uint_65535 = OpConstant %uint 65535 %27 = OpConstantComposite %v2uint %uint_65535 %uint_65535 - %uint_0 = OpConstant %uint 0 - %30 = OpConstantComposite %v2uint %uint_0 %uint_0 %uint_16 = OpConstant %uint 16 - %32 = OpConstantComposite %v2uint %uint_16 %uint_16 + %30 = OpConstantComposite %v2uint %uint_16 %uint_16 %uint_255 = OpConstant %uint 255 - %39 = OpConstantComposite %v2uint %uint_255 %uint_255 + %37 = OpConstantComposite %v2uint %uint_255 %uint_255 %uint_8 = OpConstant %uint 8 - %42 = OpConstantComposite %v2uint %uint_8 %uint_8 + %40 = OpConstantComposite %v2uint %uint_8 %uint_8 %uint_15 = OpConstant %uint 15 - %49 = OpConstantComposite %v2uint %uint_15 %uint_15 + %47 = OpConstantComposite %v2uint %uint_15 %uint_15 %uint_4 = OpConstant %uint 4 - %52 = OpConstantComposite %v2uint %uint_4 %uint_4 + %50 = OpConstantComposite %v2uint %uint_4 %uint_4 %uint_3 = OpConstant %uint 3 - %59 = OpConstantComposite %v2uint %uint_3 %uint_3 + %57 = OpConstantComposite %v2uint %uint_3 %uint_3 %uint_2 = OpConstant %uint 2 - %62 = OpConstantComposite %v2uint %uint_2 %uint_2 + %60 = OpConstantComposite %v2uint %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %69 = OpConstantComposite %v2uint %uint_1 %uint_1 + %67 = OpConstantComposite %v2uint %uint_1 %uint_1 %void = OpTypeVoid - %80 = OpTypeFunction %void - %85 = OpConstantNull %v2int + %78 = OpTypeFunction %void + %83 = OpConstantNull %v2int %_ptr_Function_v2int = OpTypePointer Function %v2int - %88 = OpTypeFunction %v4float + %86 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_count_trailing_zeros = OpFunction %v2int None %9 %v = OpFunctionParameter %v2int @@ -75,72 +73,72 @@ %25 = OpLoad %v2uint %x %28 = OpBitwiseAnd %v2uint %25 %27 %22 = OpINotEqual %v2bool %28 %20 - %21 = OpSelect %v2uint %22 %30 %32 - %33 = OpLoad %v2uint %x - %34 = OpShiftRightLogical %v2uint %33 %21 - OpStore %x %34 - %37 = OpLoad %v2uint %x - %40 = OpBitwiseAnd %v2uint %37 %39 - %36 = OpINotEqual %v2bool %40 %20 - %35 = OpSelect %v2uint %36 %30 %42 - %43 = OpLoad %v2uint %x - %44 = OpShiftRightLogical %v2uint %43 %35 - OpStore %x %44 - %47 = OpLoad %v2uint %x - %50 = OpBitwiseAnd %v2uint %47 %49 - %46 = OpINotEqual %v2bool %50 %20 - %45 = OpSelect %v2uint %46 %30 %52 - %53 = OpLoad %v2uint %x - %54 = OpShiftRightLogical %v2uint %53 %45 - OpStore %x %54 - %57 = OpLoad %v2uint %x - %60 = OpBitwiseAnd %v2uint %57 %59 - %56 = OpINotEqual %v2bool %60 %20 - %55 = OpSelect %v2uint %56 %30 %62 - %63 = OpLoad %v2uint %x - %64 = OpShiftRightLogical %v2uint %63 %55 - OpStore %x %64 - %67 = OpLoad %v2uint %x - %70 = OpBitwiseAnd %v2uint %67 %69 - %66 = OpINotEqual %v2bool %70 %20 - %65 = OpSelect %v2uint %66 %30 %69 - %72 = OpLoad %v2uint %x - %73 = OpIEqual %v2bool %72 %30 - %71 = OpSelect %v2uint %73 %69 %30 - %75 = OpBitwiseOr %v2uint %21 %35 - %76 = OpBitwiseOr %v2uint %75 %45 - %77 = OpBitwiseOr %v2uint %76 %55 - %78 = OpBitwiseOr %v2uint %77 %65 - %79 = OpIAdd %v2uint %78 %71 - %74 = OpBitcast %v2int %79 - OpReturnValue %74 + %21 = OpSelect %v2uint %22 %20 %30 + %31 = OpLoad %v2uint %x + %32 = OpShiftRightLogical %v2uint %31 %21 + OpStore %x %32 + %35 = OpLoad %v2uint %x + %38 = OpBitwiseAnd %v2uint %35 %37 + %34 = OpINotEqual %v2bool %38 %20 + %33 = OpSelect %v2uint %34 %20 %40 + %41 = OpLoad %v2uint %x + %42 = OpShiftRightLogical %v2uint %41 %33 + OpStore %x %42 + %45 = OpLoad %v2uint %x + %48 = OpBitwiseAnd %v2uint %45 %47 + %44 = OpINotEqual %v2bool %48 %20 + %43 = OpSelect %v2uint %44 %20 %50 + %51 = OpLoad %v2uint %x + %52 = OpShiftRightLogical %v2uint %51 %43 + OpStore %x %52 + %55 = OpLoad %v2uint %x + %58 = OpBitwiseAnd %v2uint %55 %57 + %54 = OpINotEqual %v2bool %58 %20 + %53 = OpSelect %v2uint %54 %20 %60 + %61 = OpLoad %v2uint %x + %62 = OpShiftRightLogical %v2uint %61 %53 + OpStore %x %62 + %65 = OpLoad %v2uint %x + %68 = OpBitwiseAnd %v2uint %65 %67 + %64 = OpINotEqual %v2bool %68 %20 + %63 = OpSelect %v2uint %64 %20 %67 + %70 = OpLoad %v2uint %x + %71 = OpIEqual %v2bool %70 %20 + %69 = OpSelect %v2uint %71 %67 %20 + %73 = OpBitwiseOr %v2uint %21 %33 + %74 = OpBitwiseOr %v2uint %73 %43 + %75 = OpBitwiseOr %v2uint %74 %53 + %76 = OpBitwiseOr %v2uint %75 %63 + %77 = OpIAdd %v2uint %76 %69 + %72 = OpBitcast %v2int %77 + OpReturnValue %72 OpFunctionEnd -%countTrailingZeros_327c37 = OpFunction %void None %80 - %83 = OpLabel - %res = OpVariable %_ptr_Function_v2int Function %85 - %84 = OpFunctionCall %v2int %tint_count_trailing_zeros %85 - OpStore %res %84 +%countTrailingZeros_327c37 = OpFunction %void None %78 + %81 = OpLabel + %res = OpVariable %_ptr_Function_v2int Function %83 + %82 = OpFunctionCall %v2int %tint_count_trailing_zeros %83 + OpStore %res %82 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %88 - %90 = OpLabel - %91 = OpFunctionCall %void %countTrailingZeros_327c37 +%vertex_main_inner = OpFunction %v4float None %86 + %88 = OpLabel + %89 = OpFunctionCall %void %countTrailingZeros_327c37 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %80 - %93 = OpLabel - %94 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %94 +%vertex_main = OpFunction %void None %78 + %91 = OpLabel + %92 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %92 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %80 - %97 = OpLabel - %98 = OpFunctionCall %void %countTrailingZeros_327c37 +%fragment_main = OpFunction %void None %78 + %95 = OpLabel + %96 = OpFunctionCall %void %countTrailingZeros_327c37 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %80 - %100 = OpLabel - %101 = OpFunctionCall %void %countTrailingZeros_327c37 +%compute_main = OpFunction %void None %78 + %98 = OpLabel + %99 = OpFunctionCall %void %countTrailingZeros_327c37 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/countTrailingZeros/42fed6.wgsl.expected.spvasm b/test/tint/builtins/gen/countTrailingZeros/42fed6.wgsl.expected.spvasm index f5adcab446..5603d88b97 100644 --- a/test/tint/builtins/gen/countTrailingZeros/42fed6.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/countTrailingZeros/42fed6.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 90 +; Bound: 89 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -38,7 +38,6 @@ %18 = OpConstantNull %uint %bool = OpTypeBool %uint_65535 = OpConstant %uint 65535 - %uint_0 = OpConstant %uint 0 %uint_16 = OpConstant %uint 16 %uint_255 = OpConstant %uint 255 %uint_8 = OpConstant %uint 8 @@ -48,11 +47,11 @@ %uint_2 = OpConstant %uint 2 %uint_1 = OpConstant %uint 1 %void = OpTypeVoid - %67 = OpTypeFunction %void + %66 = OpTypeFunction %void %int_1 = OpConstant %int 1 %_ptr_Function_int = OpTypePointer Function %int - %75 = OpConstantNull %int - %76 = OpTypeFunction %v4float + %74 = OpConstantNull %int + %75 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_count_trailing_zeros = OpFunction %int None %9 %v = OpFunctionParameter %int @@ -63,72 +62,72 @@ %22 = OpLoad %uint %x %24 = OpBitwiseAnd %uint %22 %uint_65535 %20 = OpINotEqual %bool %24 %18 - %19 = OpSelect %uint %20 %uint_0 %uint_16 - %27 = OpLoad %uint %x - %28 = OpShiftRightLogical %uint %27 %19 - OpStore %x %28 - %31 = OpLoad %uint %x - %33 = OpBitwiseAnd %uint %31 %uint_255 - %30 = OpINotEqual %bool %33 %18 - %29 = OpSelect %uint %30 %uint_0 %uint_8 - %35 = OpLoad %uint %x - %36 = OpShiftRightLogical %uint %35 %29 - OpStore %x %36 - %39 = OpLoad %uint %x - %41 = OpBitwiseAnd %uint %39 %uint_15 - %38 = OpINotEqual %bool %41 %18 - %37 = OpSelect %uint %38 %uint_0 %uint_4 - %43 = OpLoad %uint %x - %44 = OpShiftRightLogical %uint %43 %37 - OpStore %x %44 - %47 = OpLoad %uint %x - %49 = OpBitwiseAnd %uint %47 %uint_3 - %46 = OpINotEqual %bool %49 %18 - %45 = OpSelect %uint %46 %uint_0 %uint_2 - %51 = OpLoad %uint %x - %52 = OpShiftRightLogical %uint %51 %45 - OpStore %x %52 - %55 = OpLoad %uint %x - %57 = OpBitwiseAnd %uint %55 %uint_1 - %54 = OpINotEqual %bool %57 %18 - %53 = OpSelect %uint %54 %uint_0 %uint_1 - %59 = OpLoad %uint %x - %60 = OpIEqual %bool %59 %uint_0 - %58 = OpSelect %uint %60 %uint_1 %uint_0 - %62 = OpBitwiseOr %uint %19 %29 - %63 = OpBitwiseOr %uint %62 %37 - %64 = OpBitwiseOr %uint %63 %45 - %65 = OpBitwiseOr %uint %64 %53 - %66 = OpIAdd %uint %65 %58 - %61 = OpBitcast %int %66 - OpReturnValue %61 + %19 = OpSelect %uint %20 %18 %uint_16 + %26 = OpLoad %uint %x + %27 = OpShiftRightLogical %uint %26 %19 + OpStore %x %27 + %30 = OpLoad %uint %x + %32 = OpBitwiseAnd %uint %30 %uint_255 + %29 = OpINotEqual %bool %32 %18 + %28 = OpSelect %uint %29 %18 %uint_8 + %34 = OpLoad %uint %x + %35 = OpShiftRightLogical %uint %34 %28 + OpStore %x %35 + %38 = OpLoad %uint %x + %40 = OpBitwiseAnd %uint %38 %uint_15 + %37 = OpINotEqual %bool %40 %18 + %36 = OpSelect %uint %37 %18 %uint_4 + %42 = OpLoad %uint %x + %43 = OpShiftRightLogical %uint %42 %36 + OpStore %x %43 + %46 = OpLoad %uint %x + %48 = OpBitwiseAnd %uint %46 %uint_3 + %45 = OpINotEqual %bool %48 %18 + %44 = OpSelect %uint %45 %18 %uint_2 + %50 = OpLoad %uint %x + %51 = OpShiftRightLogical %uint %50 %44 + OpStore %x %51 + %54 = OpLoad %uint %x + %56 = OpBitwiseAnd %uint %54 %uint_1 + %53 = OpINotEqual %bool %56 %18 + %52 = OpSelect %uint %53 %18 %uint_1 + %58 = OpLoad %uint %x + %59 = OpIEqual %bool %58 %18 + %57 = OpSelect %uint %59 %uint_1 %18 + %61 = OpBitwiseOr %uint %19 %28 + %62 = OpBitwiseOr %uint %61 %36 + %63 = OpBitwiseOr %uint %62 %44 + %64 = OpBitwiseOr %uint %63 %52 + %65 = OpIAdd %uint %64 %57 + %60 = OpBitcast %int %65 + OpReturnValue %60 OpFunctionEnd -%countTrailingZeros_42fed6 = OpFunction %void None %67 - %70 = OpLabel - %res = OpVariable %_ptr_Function_int Function %75 - %71 = OpFunctionCall %int %tint_count_trailing_zeros %int_1 - OpStore %res %71 +%countTrailingZeros_42fed6 = OpFunction %void None %66 + %69 = OpLabel + %res = OpVariable %_ptr_Function_int Function %74 + %70 = OpFunctionCall %int %tint_count_trailing_zeros %int_1 + OpStore %res %70 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %76 - %78 = OpLabel - %79 = OpFunctionCall %void %countTrailingZeros_42fed6 +%vertex_main_inner = OpFunction %v4float None %75 + %77 = OpLabel + %78 = OpFunctionCall %void %countTrailingZeros_42fed6 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %67 - %81 = OpLabel - %82 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %82 +%vertex_main = OpFunction %void None %66 + %80 = OpLabel + %81 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %81 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %67 - %85 = OpLabel - %86 = OpFunctionCall %void %countTrailingZeros_42fed6 +%fragment_main = OpFunction %void None %66 + %84 = OpLabel + %85 = OpFunctionCall %void %countTrailingZeros_42fed6 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %67 - %88 = OpLabel - %89 = OpFunctionCall %void %countTrailingZeros_42fed6 +%compute_main = OpFunction %void None %66 + %87 = OpLabel + %88 = OpFunctionCall %void %countTrailingZeros_42fed6 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/countTrailingZeros/8ed26f.wgsl.expected.spvasm b/test/tint/builtins/gen/countTrailingZeros/8ed26f.wgsl.expected.spvasm index 00db3764f5..ccb9e6f9a8 100644 --- a/test/tint/builtins/gen/countTrailingZeros/8ed26f.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/countTrailingZeros/8ed26f.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 98 +; Bound: 96 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -40,27 +40,25 @@ %v3bool = OpTypeVector %bool 3 %uint_65535 = OpConstant %uint 65535 %25 = OpConstantComposite %v3uint %uint_65535 %uint_65535 %uint_65535 - %uint_0 = OpConstant %uint 0 - %28 = OpConstantComposite %v3uint %uint_0 %uint_0 %uint_0 %uint_16 = OpConstant %uint 16 - %30 = OpConstantComposite %v3uint %uint_16 %uint_16 %uint_16 + %28 = OpConstantComposite %v3uint %uint_16 %uint_16 %uint_16 %uint_255 = OpConstant %uint 255 - %37 = OpConstantComposite %v3uint %uint_255 %uint_255 %uint_255 + %35 = OpConstantComposite %v3uint %uint_255 %uint_255 %uint_255 %uint_8 = OpConstant %uint 8 - %40 = OpConstantComposite %v3uint %uint_8 %uint_8 %uint_8 + %38 = OpConstantComposite %v3uint %uint_8 %uint_8 %uint_8 %uint_15 = OpConstant %uint 15 - %47 = OpConstantComposite %v3uint %uint_15 %uint_15 %uint_15 + %45 = OpConstantComposite %v3uint %uint_15 %uint_15 %uint_15 %uint_4 = OpConstant %uint 4 - %50 = OpConstantComposite %v3uint %uint_4 %uint_4 %uint_4 + %48 = OpConstantComposite %v3uint %uint_4 %uint_4 %uint_4 %uint_3 = OpConstant %uint 3 - %57 = OpConstantComposite %v3uint %uint_3 %uint_3 %uint_3 + %55 = OpConstantComposite %v3uint %uint_3 %uint_3 %uint_3 %uint_2 = OpConstant %uint 2 - %60 = OpConstantComposite %v3uint %uint_2 %uint_2 %uint_2 + %58 = OpConstantComposite %v3uint %uint_2 %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %67 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 + %65 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %void = OpTypeVoid - %78 = OpTypeFunction %void - %84 = OpTypeFunction %v4float + %76 = OpTypeFunction %void + %82 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_count_trailing_zeros = OpFunction %v3uint None %9 %v = OpFunctionParameter %v3uint @@ -70,71 +68,71 @@ %23 = OpLoad %v3uint %x %26 = OpBitwiseAnd %v3uint %23 %25 %20 = OpINotEqual %v3bool %26 %18 - %19 = OpSelect %v3uint %20 %28 %30 - %31 = OpLoad %v3uint %x - %32 = OpShiftRightLogical %v3uint %31 %19 - OpStore %x %32 - %35 = OpLoad %v3uint %x - %38 = OpBitwiseAnd %v3uint %35 %37 - %34 = OpINotEqual %v3bool %38 %18 - %33 = OpSelect %v3uint %34 %28 %40 - %41 = OpLoad %v3uint %x - %42 = OpShiftRightLogical %v3uint %41 %33 - OpStore %x %42 - %45 = OpLoad %v3uint %x - %48 = OpBitwiseAnd %v3uint %45 %47 - %44 = OpINotEqual %v3bool %48 %18 - %43 = OpSelect %v3uint %44 %28 %50 - %51 = OpLoad %v3uint %x - %52 = OpShiftRightLogical %v3uint %51 %43 - OpStore %x %52 - %55 = OpLoad %v3uint %x - %58 = OpBitwiseAnd %v3uint %55 %57 - %54 = OpINotEqual %v3bool %58 %18 - %53 = OpSelect %v3uint %54 %28 %60 - %61 = OpLoad %v3uint %x - %62 = OpShiftRightLogical %v3uint %61 %53 - OpStore %x %62 - %65 = OpLoad %v3uint %x - %68 = OpBitwiseAnd %v3uint %65 %67 - %64 = OpINotEqual %v3bool %68 %18 - %63 = OpSelect %v3uint %64 %28 %67 - %70 = OpLoad %v3uint %x - %71 = OpIEqual %v3bool %70 %28 - %69 = OpSelect %v3uint %71 %67 %28 - %73 = OpBitwiseOr %v3uint %19 %33 - %74 = OpBitwiseOr %v3uint %73 %43 - %75 = OpBitwiseOr %v3uint %74 %53 - %76 = OpBitwiseOr %v3uint %75 %63 - %77 = OpIAdd %v3uint %76 %69 - OpReturnValue %77 + %19 = OpSelect %v3uint %20 %18 %28 + %29 = OpLoad %v3uint %x + %30 = OpShiftRightLogical %v3uint %29 %19 + OpStore %x %30 + %33 = OpLoad %v3uint %x + %36 = OpBitwiseAnd %v3uint %33 %35 + %32 = OpINotEqual %v3bool %36 %18 + %31 = OpSelect %v3uint %32 %18 %38 + %39 = OpLoad %v3uint %x + %40 = OpShiftRightLogical %v3uint %39 %31 + OpStore %x %40 + %43 = OpLoad %v3uint %x + %46 = OpBitwiseAnd %v3uint %43 %45 + %42 = OpINotEqual %v3bool %46 %18 + %41 = OpSelect %v3uint %42 %18 %48 + %49 = OpLoad %v3uint %x + %50 = OpShiftRightLogical %v3uint %49 %41 + OpStore %x %50 + %53 = OpLoad %v3uint %x + %56 = OpBitwiseAnd %v3uint %53 %55 + %52 = OpINotEqual %v3bool %56 %18 + %51 = OpSelect %v3uint %52 %18 %58 + %59 = OpLoad %v3uint %x + %60 = OpShiftRightLogical %v3uint %59 %51 + OpStore %x %60 + %63 = OpLoad %v3uint %x + %66 = OpBitwiseAnd %v3uint %63 %65 + %62 = OpINotEqual %v3bool %66 %18 + %61 = OpSelect %v3uint %62 %18 %65 + %68 = OpLoad %v3uint %x + %69 = OpIEqual %v3bool %68 %18 + %67 = OpSelect %v3uint %69 %65 %18 + %71 = OpBitwiseOr %v3uint %19 %31 + %72 = OpBitwiseOr %v3uint %71 %41 + %73 = OpBitwiseOr %v3uint %72 %51 + %74 = OpBitwiseOr %v3uint %73 %61 + %75 = OpIAdd %v3uint %74 %67 + OpReturnValue %75 OpFunctionEnd -%countTrailingZeros_8ed26f = OpFunction %void None %78 - %81 = OpLabel +%countTrailingZeros_8ed26f = OpFunction %void None %76 + %79 = OpLabel %res = OpVariable %_ptr_Function_v3uint Function %18 - %82 = OpFunctionCall %v3uint %tint_count_trailing_zeros %18 - OpStore %res %82 + %80 = OpFunctionCall %v3uint %tint_count_trailing_zeros %18 + OpStore %res %80 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %84 - %86 = OpLabel - %87 = OpFunctionCall %void %countTrailingZeros_8ed26f +%vertex_main_inner = OpFunction %v4float None %82 + %84 = OpLabel + %85 = OpFunctionCall %void %countTrailingZeros_8ed26f OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %78 - %89 = OpLabel - %90 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %90 +%vertex_main = OpFunction %void None %76 + %87 = OpLabel + %88 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %88 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %78 - %93 = OpLabel - %94 = OpFunctionCall %void %countTrailingZeros_8ed26f +%fragment_main = OpFunction %void None %76 + %91 = OpLabel + %92 = OpFunctionCall %void %countTrailingZeros_8ed26f OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %78 - %96 = OpLabel - %97 = OpFunctionCall %void %countTrailingZeros_8ed26f +%compute_main = OpFunction %void None %76 + %94 = OpLabel + %95 = OpFunctionCall %void %countTrailingZeros_8ed26f OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/countTrailingZeros/acfacb.wgsl.expected.spvasm b/test/tint/builtins/gen/countTrailingZeros/acfacb.wgsl.expected.spvasm index 777e2ede10..9c2dda8b09 100644 --- a/test/tint/builtins/gen/countTrailingZeros/acfacb.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/countTrailingZeros/acfacb.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 102 +; Bound: 100 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -42,29 +42,27 @@ %v3bool = OpTypeVector %bool 3 %uint_65535 = OpConstant %uint 65535 %27 = OpConstantComposite %v3uint %uint_65535 %uint_65535 %uint_65535 - %uint_0 = OpConstant %uint 0 - %30 = OpConstantComposite %v3uint %uint_0 %uint_0 %uint_0 %uint_16 = OpConstant %uint 16 - %32 = OpConstantComposite %v3uint %uint_16 %uint_16 %uint_16 + %30 = OpConstantComposite %v3uint %uint_16 %uint_16 %uint_16 %uint_255 = OpConstant %uint 255 - %39 = OpConstantComposite %v3uint %uint_255 %uint_255 %uint_255 + %37 = OpConstantComposite %v3uint %uint_255 %uint_255 %uint_255 %uint_8 = OpConstant %uint 8 - %42 = OpConstantComposite %v3uint %uint_8 %uint_8 %uint_8 + %40 = OpConstantComposite %v3uint %uint_8 %uint_8 %uint_8 %uint_15 = OpConstant %uint 15 - %49 = OpConstantComposite %v3uint %uint_15 %uint_15 %uint_15 + %47 = OpConstantComposite %v3uint %uint_15 %uint_15 %uint_15 %uint_4 = OpConstant %uint 4 - %52 = OpConstantComposite %v3uint %uint_4 %uint_4 %uint_4 + %50 = OpConstantComposite %v3uint %uint_4 %uint_4 %uint_4 %uint_3 = OpConstant %uint 3 - %59 = OpConstantComposite %v3uint %uint_3 %uint_3 %uint_3 + %57 = OpConstantComposite %v3uint %uint_3 %uint_3 %uint_3 %uint_2 = OpConstant %uint 2 - %62 = OpConstantComposite %v3uint %uint_2 %uint_2 %uint_2 + %60 = OpConstantComposite %v3uint %uint_2 %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %69 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 + %67 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %void = OpTypeVoid - %80 = OpTypeFunction %void - %85 = OpConstantNull %v3int + %78 = OpTypeFunction %void + %83 = OpConstantNull %v3int %_ptr_Function_v3int = OpTypePointer Function %v3int - %88 = OpTypeFunction %v4float + %86 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_count_trailing_zeros = OpFunction %v3int None %9 %v = OpFunctionParameter %v3int @@ -75,72 +73,72 @@ %25 = OpLoad %v3uint %x %28 = OpBitwiseAnd %v3uint %25 %27 %22 = OpINotEqual %v3bool %28 %20 - %21 = OpSelect %v3uint %22 %30 %32 - %33 = OpLoad %v3uint %x - %34 = OpShiftRightLogical %v3uint %33 %21 - OpStore %x %34 - %37 = OpLoad %v3uint %x - %40 = OpBitwiseAnd %v3uint %37 %39 - %36 = OpINotEqual %v3bool %40 %20 - %35 = OpSelect %v3uint %36 %30 %42 - %43 = OpLoad %v3uint %x - %44 = OpShiftRightLogical %v3uint %43 %35 - OpStore %x %44 - %47 = OpLoad %v3uint %x - %50 = OpBitwiseAnd %v3uint %47 %49 - %46 = OpINotEqual %v3bool %50 %20 - %45 = OpSelect %v3uint %46 %30 %52 - %53 = OpLoad %v3uint %x - %54 = OpShiftRightLogical %v3uint %53 %45 - OpStore %x %54 - %57 = OpLoad %v3uint %x - %60 = OpBitwiseAnd %v3uint %57 %59 - %56 = OpINotEqual %v3bool %60 %20 - %55 = OpSelect %v3uint %56 %30 %62 - %63 = OpLoad %v3uint %x - %64 = OpShiftRightLogical %v3uint %63 %55 - OpStore %x %64 - %67 = OpLoad %v3uint %x - %70 = OpBitwiseAnd %v3uint %67 %69 - %66 = OpINotEqual %v3bool %70 %20 - %65 = OpSelect %v3uint %66 %30 %69 - %72 = OpLoad %v3uint %x - %73 = OpIEqual %v3bool %72 %30 - %71 = OpSelect %v3uint %73 %69 %30 - %75 = OpBitwiseOr %v3uint %21 %35 - %76 = OpBitwiseOr %v3uint %75 %45 - %77 = OpBitwiseOr %v3uint %76 %55 - %78 = OpBitwiseOr %v3uint %77 %65 - %79 = OpIAdd %v3uint %78 %71 - %74 = OpBitcast %v3int %79 - OpReturnValue %74 + %21 = OpSelect %v3uint %22 %20 %30 + %31 = OpLoad %v3uint %x + %32 = OpShiftRightLogical %v3uint %31 %21 + OpStore %x %32 + %35 = OpLoad %v3uint %x + %38 = OpBitwiseAnd %v3uint %35 %37 + %34 = OpINotEqual %v3bool %38 %20 + %33 = OpSelect %v3uint %34 %20 %40 + %41 = OpLoad %v3uint %x + %42 = OpShiftRightLogical %v3uint %41 %33 + OpStore %x %42 + %45 = OpLoad %v3uint %x + %48 = OpBitwiseAnd %v3uint %45 %47 + %44 = OpINotEqual %v3bool %48 %20 + %43 = OpSelect %v3uint %44 %20 %50 + %51 = OpLoad %v3uint %x + %52 = OpShiftRightLogical %v3uint %51 %43 + OpStore %x %52 + %55 = OpLoad %v3uint %x + %58 = OpBitwiseAnd %v3uint %55 %57 + %54 = OpINotEqual %v3bool %58 %20 + %53 = OpSelect %v3uint %54 %20 %60 + %61 = OpLoad %v3uint %x + %62 = OpShiftRightLogical %v3uint %61 %53 + OpStore %x %62 + %65 = OpLoad %v3uint %x + %68 = OpBitwiseAnd %v3uint %65 %67 + %64 = OpINotEqual %v3bool %68 %20 + %63 = OpSelect %v3uint %64 %20 %67 + %70 = OpLoad %v3uint %x + %71 = OpIEqual %v3bool %70 %20 + %69 = OpSelect %v3uint %71 %67 %20 + %73 = OpBitwiseOr %v3uint %21 %33 + %74 = OpBitwiseOr %v3uint %73 %43 + %75 = OpBitwiseOr %v3uint %74 %53 + %76 = OpBitwiseOr %v3uint %75 %63 + %77 = OpIAdd %v3uint %76 %69 + %72 = OpBitcast %v3int %77 + OpReturnValue %72 OpFunctionEnd -%countTrailingZeros_acfacb = OpFunction %void None %80 - %83 = OpLabel - %res = OpVariable %_ptr_Function_v3int Function %85 - %84 = OpFunctionCall %v3int %tint_count_trailing_zeros %85 - OpStore %res %84 +%countTrailingZeros_acfacb = OpFunction %void None %78 + %81 = OpLabel + %res = OpVariable %_ptr_Function_v3int Function %83 + %82 = OpFunctionCall %v3int %tint_count_trailing_zeros %83 + OpStore %res %82 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %88 - %90 = OpLabel - %91 = OpFunctionCall %void %countTrailingZeros_acfacb +%vertex_main_inner = OpFunction %v4float None %86 + %88 = OpLabel + %89 = OpFunctionCall %void %countTrailingZeros_acfacb OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %80 - %93 = OpLabel - %94 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %94 +%vertex_main = OpFunction %void None %78 + %91 = OpLabel + %92 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %92 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %80 - %97 = OpLabel - %98 = OpFunctionCall %void %countTrailingZeros_acfacb +%fragment_main = OpFunction %void None %78 + %95 = OpLabel + %96 = OpFunctionCall %void %countTrailingZeros_acfacb OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %80 - %100 = OpLabel - %101 = OpFunctionCall %void %countTrailingZeros_acfacb +%compute_main = OpFunction %void None %78 + %98 = OpLabel + %99 = OpFunctionCall %void %countTrailingZeros_acfacb OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/countTrailingZeros/d2b4a0.wgsl.expected.spvasm b/test/tint/builtins/gen/countTrailingZeros/d2b4a0.wgsl.expected.spvasm index 356c4169eb..21b14de6ed 100644 --- a/test/tint/builtins/gen/countTrailingZeros/d2b4a0.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/countTrailingZeros/d2b4a0.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 98 +; Bound: 96 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -40,27 +40,25 @@ %v4bool = OpTypeVector %bool 4 %uint_65535 = OpConstant %uint 65535 %25 = OpConstantComposite %v4uint %uint_65535 %uint_65535 %uint_65535 %uint_65535 - %uint_0 = OpConstant %uint 0 - %28 = OpConstantComposite %v4uint %uint_0 %uint_0 %uint_0 %uint_0 %uint_16 = OpConstant %uint 16 - %30 = OpConstantComposite %v4uint %uint_16 %uint_16 %uint_16 %uint_16 + %28 = OpConstantComposite %v4uint %uint_16 %uint_16 %uint_16 %uint_16 %uint_255 = OpConstant %uint 255 - %37 = OpConstantComposite %v4uint %uint_255 %uint_255 %uint_255 %uint_255 + %35 = OpConstantComposite %v4uint %uint_255 %uint_255 %uint_255 %uint_255 %uint_8 = OpConstant %uint 8 - %40 = OpConstantComposite %v4uint %uint_8 %uint_8 %uint_8 %uint_8 + %38 = OpConstantComposite %v4uint %uint_8 %uint_8 %uint_8 %uint_8 %uint_15 = OpConstant %uint 15 - %47 = OpConstantComposite %v4uint %uint_15 %uint_15 %uint_15 %uint_15 + %45 = OpConstantComposite %v4uint %uint_15 %uint_15 %uint_15 %uint_15 %uint_4 = OpConstant %uint 4 - %50 = OpConstantComposite %v4uint %uint_4 %uint_4 %uint_4 %uint_4 + %48 = OpConstantComposite %v4uint %uint_4 %uint_4 %uint_4 %uint_4 %uint_3 = OpConstant %uint 3 - %57 = OpConstantComposite %v4uint %uint_3 %uint_3 %uint_3 %uint_3 + %55 = OpConstantComposite %v4uint %uint_3 %uint_3 %uint_3 %uint_3 %uint_2 = OpConstant %uint 2 - %60 = OpConstantComposite %v4uint %uint_2 %uint_2 %uint_2 %uint_2 + %58 = OpConstantComposite %v4uint %uint_2 %uint_2 %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %67 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 + %65 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 %void = OpTypeVoid - %78 = OpTypeFunction %void - %84 = OpTypeFunction %v4float + %76 = OpTypeFunction %void + %82 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_count_trailing_zeros = OpFunction %v4uint None %9 %v = OpFunctionParameter %v4uint @@ -70,71 +68,71 @@ %23 = OpLoad %v4uint %x %26 = OpBitwiseAnd %v4uint %23 %25 %20 = OpINotEqual %v4bool %26 %18 - %19 = OpSelect %v4uint %20 %28 %30 - %31 = OpLoad %v4uint %x - %32 = OpShiftRightLogical %v4uint %31 %19 - OpStore %x %32 - %35 = OpLoad %v4uint %x - %38 = OpBitwiseAnd %v4uint %35 %37 - %34 = OpINotEqual %v4bool %38 %18 - %33 = OpSelect %v4uint %34 %28 %40 - %41 = OpLoad %v4uint %x - %42 = OpShiftRightLogical %v4uint %41 %33 - OpStore %x %42 - %45 = OpLoad %v4uint %x - %48 = OpBitwiseAnd %v4uint %45 %47 - %44 = OpINotEqual %v4bool %48 %18 - %43 = OpSelect %v4uint %44 %28 %50 - %51 = OpLoad %v4uint %x - %52 = OpShiftRightLogical %v4uint %51 %43 - OpStore %x %52 - %55 = OpLoad %v4uint %x - %58 = OpBitwiseAnd %v4uint %55 %57 - %54 = OpINotEqual %v4bool %58 %18 - %53 = OpSelect %v4uint %54 %28 %60 - %61 = OpLoad %v4uint %x - %62 = OpShiftRightLogical %v4uint %61 %53 - OpStore %x %62 - %65 = OpLoad %v4uint %x - %68 = OpBitwiseAnd %v4uint %65 %67 - %64 = OpINotEqual %v4bool %68 %18 - %63 = OpSelect %v4uint %64 %28 %67 - %70 = OpLoad %v4uint %x - %71 = OpIEqual %v4bool %70 %28 - %69 = OpSelect %v4uint %71 %67 %28 - %73 = OpBitwiseOr %v4uint %19 %33 - %74 = OpBitwiseOr %v4uint %73 %43 - %75 = OpBitwiseOr %v4uint %74 %53 - %76 = OpBitwiseOr %v4uint %75 %63 - %77 = OpIAdd %v4uint %76 %69 - OpReturnValue %77 + %19 = OpSelect %v4uint %20 %18 %28 + %29 = OpLoad %v4uint %x + %30 = OpShiftRightLogical %v4uint %29 %19 + OpStore %x %30 + %33 = OpLoad %v4uint %x + %36 = OpBitwiseAnd %v4uint %33 %35 + %32 = OpINotEqual %v4bool %36 %18 + %31 = OpSelect %v4uint %32 %18 %38 + %39 = OpLoad %v4uint %x + %40 = OpShiftRightLogical %v4uint %39 %31 + OpStore %x %40 + %43 = OpLoad %v4uint %x + %46 = OpBitwiseAnd %v4uint %43 %45 + %42 = OpINotEqual %v4bool %46 %18 + %41 = OpSelect %v4uint %42 %18 %48 + %49 = OpLoad %v4uint %x + %50 = OpShiftRightLogical %v4uint %49 %41 + OpStore %x %50 + %53 = OpLoad %v4uint %x + %56 = OpBitwiseAnd %v4uint %53 %55 + %52 = OpINotEqual %v4bool %56 %18 + %51 = OpSelect %v4uint %52 %18 %58 + %59 = OpLoad %v4uint %x + %60 = OpShiftRightLogical %v4uint %59 %51 + OpStore %x %60 + %63 = OpLoad %v4uint %x + %66 = OpBitwiseAnd %v4uint %63 %65 + %62 = OpINotEqual %v4bool %66 %18 + %61 = OpSelect %v4uint %62 %18 %65 + %68 = OpLoad %v4uint %x + %69 = OpIEqual %v4bool %68 %18 + %67 = OpSelect %v4uint %69 %65 %18 + %71 = OpBitwiseOr %v4uint %19 %31 + %72 = OpBitwiseOr %v4uint %71 %41 + %73 = OpBitwiseOr %v4uint %72 %51 + %74 = OpBitwiseOr %v4uint %73 %61 + %75 = OpIAdd %v4uint %74 %67 + OpReturnValue %75 OpFunctionEnd -%countTrailingZeros_d2b4a0 = OpFunction %void None %78 - %81 = OpLabel +%countTrailingZeros_d2b4a0 = OpFunction %void None %76 + %79 = OpLabel %res = OpVariable %_ptr_Function_v4uint Function %18 - %82 = OpFunctionCall %v4uint %tint_count_trailing_zeros %18 - OpStore %res %82 + %80 = OpFunctionCall %v4uint %tint_count_trailing_zeros %18 + OpStore %res %80 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %84 - %86 = OpLabel - %87 = OpFunctionCall %void %countTrailingZeros_d2b4a0 +%vertex_main_inner = OpFunction %v4float None %82 + %84 = OpLabel + %85 = OpFunctionCall %void %countTrailingZeros_d2b4a0 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %78 - %89 = OpLabel - %90 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %90 +%vertex_main = OpFunction %void None %76 + %87 = OpLabel + %88 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %88 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %78 - %93 = OpLabel - %94 = OpFunctionCall %void %countTrailingZeros_d2b4a0 +%fragment_main = OpFunction %void None %76 + %91 = OpLabel + %92 = OpFunctionCall %void %countTrailingZeros_d2b4a0 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %78 - %96 = OpLabel - %97 = OpFunctionCall %void %countTrailingZeros_d2b4a0 +%compute_main = OpFunction %void None %76 + %94 = OpLabel + %95 = OpFunctionCall %void %countTrailingZeros_d2b4a0 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/firstLeadingBit/000ff3.wgsl.expected.spvasm b/test/tint/builtins/gen/firstLeadingBit/000ff3.wgsl.expected.spvasm index a7000b08af..bf28342a23 100644 --- a/test/tint/builtins/gen/firstLeadingBit/000ff3.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/firstLeadingBit/000ff3.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 99 +; Bound: 97 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -42,27 +42,25 @@ %24 = OpConstantComposite %v4uint %uint_4294901760 %uint_4294901760 %uint_4294901760 %uint_4294901760 %uint_16 = OpConstant %uint 16 %27 = OpConstantComposite %v4uint %uint_16 %uint_16 %uint_16 %uint_16 - %uint_0 = OpConstant %uint 0 - %29 = OpConstantComposite %v4uint %uint_0 %uint_0 %uint_0 %uint_0 %uint_65280 = OpConstant %uint 65280 - %36 = OpConstantComposite %v4uint %uint_65280 %uint_65280 %uint_65280 %uint_65280 + %34 = OpConstantComposite %v4uint %uint_65280 %uint_65280 %uint_65280 %uint_65280 %uint_8 = OpConstant %uint 8 - %39 = OpConstantComposite %v4uint %uint_8 %uint_8 %uint_8 %uint_8 + %37 = OpConstantComposite %v4uint %uint_8 %uint_8 %uint_8 %uint_8 %uint_240 = OpConstant %uint 240 - %46 = OpConstantComposite %v4uint %uint_240 %uint_240 %uint_240 %uint_240 + %44 = OpConstantComposite %v4uint %uint_240 %uint_240 %uint_240 %uint_240 %uint_4 = OpConstant %uint 4 - %49 = OpConstantComposite %v4uint %uint_4 %uint_4 %uint_4 %uint_4 + %47 = OpConstantComposite %v4uint %uint_4 %uint_4 %uint_4 %uint_4 %uint_12 = OpConstant %uint 12 - %56 = OpConstantComposite %v4uint %uint_12 %uint_12 %uint_12 %uint_12 + %54 = OpConstantComposite %v4uint %uint_12 %uint_12 %uint_12 %uint_12 %uint_2 = OpConstant %uint 2 - %59 = OpConstantComposite %v4uint %uint_2 %uint_2 %uint_2 %uint_2 + %57 = OpConstantComposite %v4uint %uint_2 %uint_2 %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %67 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 + %65 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 %uint_4294967295 = OpConstant %uint 4294967295 - %72 = OpConstantComposite %v4uint %uint_4294967295 %uint_4294967295 %uint_4294967295 %uint_4294967295 + %70 = OpConstantComposite %v4uint %uint_4294967295 %uint_4294967295 %uint_4294967295 %uint_4294967295 %void = OpTypeVoid - %79 = OpTypeFunction %void - %85 = OpTypeFunction %v4float + %77 = OpTypeFunction %void + %83 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_first_leading_bit = OpFunction %v4uint None %9 %v = OpFunctionParameter %v4uint @@ -72,71 +70,71 @@ %22 = OpLoad %v4uint %x %25 = OpBitwiseAnd %v4uint %22 %24 %19 = OpINotEqual %v4bool %25 %17 - %18 = OpSelect %v4uint %19 %27 %29 - %30 = OpLoad %v4uint %x - %31 = OpShiftRightLogical %v4uint %30 %18 - OpStore %x %31 - %34 = OpLoad %v4uint %x - %37 = OpBitwiseAnd %v4uint %34 %36 - %33 = OpINotEqual %v4bool %37 %17 - %32 = OpSelect %v4uint %33 %39 %29 - %40 = OpLoad %v4uint %x - %41 = OpShiftRightLogical %v4uint %40 %32 - OpStore %x %41 - %44 = OpLoad %v4uint %x - %47 = OpBitwiseAnd %v4uint %44 %46 - %43 = OpINotEqual %v4bool %47 %17 - %42 = OpSelect %v4uint %43 %49 %29 - %50 = OpLoad %v4uint %x - %51 = OpShiftRightLogical %v4uint %50 %42 - OpStore %x %51 - %54 = OpLoad %v4uint %x - %57 = OpBitwiseAnd %v4uint %54 %56 - %53 = OpINotEqual %v4bool %57 %17 - %52 = OpSelect %v4uint %53 %59 %29 - %60 = OpLoad %v4uint %x - %61 = OpShiftRightLogical %v4uint %60 %52 - OpStore %x %61 - %64 = OpLoad %v4uint %x - %65 = OpBitwiseAnd %v4uint %64 %59 - %63 = OpINotEqual %v4bool %65 %17 - %62 = OpSelect %v4uint %63 %67 %29 - %69 = OpLoad %v4uint %x - %70 = OpIEqual %v4bool %69 %29 - %68 = OpSelect %v4uint %70 %72 %29 - %74 = OpBitwiseOr %v4uint %18 %32 - %75 = OpBitwiseOr %v4uint %74 %42 - %76 = OpBitwiseOr %v4uint %75 %52 - %77 = OpBitwiseOr %v4uint %76 %62 - %78 = OpBitwiseOr %v4uint %77 %68 - OpReturnValue %78 + %18 = OpSelect %v4uint %19 %27 %17 + %28 = OpLoad %v4uint %x + %29 = OpShiftRightLogical %v4uint %28 %18 + OpStore %x %29 + %32 = OpLoad %v4uint %x + %35 = OpBitwiseAnd %v4uint %32 %34 + %31 = OpINotEqual %v4bool %35 %17 + %30 = OpSelect %v4uint %31 %37 %17 + %38 = OpLoad %v4uint %x + %39 = OpShiftRightLogical %v4uint %38 %30 + OpStore %x %39 + %42 = OpLoad %v4uint %x + %45 = OpBitwiseAnd %v4uint %42 %44 + %41 = OpINotEqual %v4bool %45 %17 + %40 = OpSelect %v4uint %41 %47 %17 + %48 = OpLoad %v4uint %x + %49 = OpShiftRightLogical %v4uint %48 %40 + OpStore %x %49 + %52 = OpLoad %v4uint %x + %55 = OpBitwiseAnd %v4uint %52 %54 + %51 = OpINotEqual %v4bool %55 %17 + %50 = OpSelect %v4uint %51 %57 %17 + %58 = OpLoad %v4uint %x + %59 = OpShiftRightLogical %v4uint %58 %50 + OpStore %x %59 + %62 = OpLoad %v4uint %x + %63 = OpBitwiseAnd %v4uint %62 %57 + %61 = OpINotEqual %v4bool %63 %17 + %60 = OpSelect %v4uint %61 %65 %17 + %67 = OpLoad %v4uint %x + %68 = OpIEqual %v4bool %67 %17 + %66 = OpSelect %v4uint %68 %70 %17 + %72 = OpBitwiseOr %v4uint %18 %30 + %73 = OpBitwiseOr %v4uint %72 %40 + %74 = OpBitwiseOr %v4uint %73 %50 + %75 = OpBitwiseOr %v4uint %74 %60 + %76 = OpBitwiseOr %v4uint %75 %66 + OpReturnValue %76 OpFunctionEnd -%firstLeadingBit_000ff3 = OpFunction %void None %79 - %82 = OpLabel +%firstLeadingBit_000ff3 = OpFunction %void None %77 + %80 = OpLabel %res = OpVariable %_ptr_Function_v4uint Function %17 - %83 = OpFunctionCall %v4uint %tint_first_leading_bit %17 - OpStore %res %83 + %81 = OpFunctionCall %v4uint %tint_first_leading_bit %17 + OpStore %res %81 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %85 - %87 = OpLabel - %88 = OpFunctionCall %void %firstLeadingBit_000ff3 +%vertex_main_inner = OpFunction %v4float None %83 + %85 = OpLabel + %86 = OpFunctionCall %void %firstLeadingBit_000ff3 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %79 - %90 = OpLabel - %91 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %91 +%vertex_main = OpFunction %void None %77 + %88 = OpLabel + %89 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %89 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %79 - %94 = OpLabel - %95 = OpFunctionCall %void %firstLeadingBit_000ff3 +%fragment_main = OpFunction %void None %77 + %92 = OpLabel + %93 = OpFunctionCall %void %firstLeadingBit_000ff3 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %79 - %97 = OpLabel - %98 = OpFunctionCall %void %firstLeadingBit_000ff3 +%compute_main = OpFunction %void None %77 + %95 = OpLabel + %96 = OpFunctionCall %void %firstLeadingBit_000ff3 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/firstLeadingBit/35053e.wgsl.expected.spvasm b/test/tint/builtins/gen/firstLeadingBit/35053e.wgsl.expected.spvasm index f35960a9f5..3d5832e7c8 100644 --- a/test/tint/builtins/gen/firstLeadingBit/35053e.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/firstLeadingBit/35053e.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 110 +; Bound: 106 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -36,119 +36,115 @@ %9 = OpTypeFunction %v3int %v3int %uint = OpTypeInt 32 0 %v3uint = OpTypeVector %uint 3 - %int_0 = OpConstant %int 0 - %19 = OpConstantComposite %v3int %int_0 %int_0 %int_0 + %18 = OpConstantNull %v3int %bool = OpTypeBool %v3bool = OpTypeVector %bool 3 %_ptr_Function_v3uint = OpTypePointer Function %v3uint - %28 = OpConstantNull %v3uint + %27 = OpConstantNull %v3uint %uint_4294901760 = OpConstant %uint 4294901760 - %33 = OpConstantComposite %v3uint %uint_4294901760 %uint_4294901760 %uint_4294901760 + %32 = OpConstantComposite %v3uint %uint_4294901760 %uint_4294901760 %uint_4294901760 %uint_16 = OpConstant %uint 16 - %36 = OpConstantComposite %v3uint %uint_16 %uint_16 %uint_16 - %uint_0 = OpConstant %uint 0 - %38 = OpConstantComposite %v3uint %uint_0 %uint_0 %uint_0 + %35 = OpConstantComposite %v3uint %uint_16 %uint_16 %uint_16 %uint_65280 = OpConstant %uint 65280 - %45 = OpConstantComposite %v3uint %uint_65280 %uint_65280 %uint_65280 + %42 = OpConstantComposite %v3uint %uint_65280 %uint_65280 %uint_65280 %uint_8 = OpConstant %uint 8 - %48 = OpConstantComposite %v3uint %uint_8 %uint_8 %uint_8 + %45 = OpConstantComposite %v3uint %uint_8 %uint_8 %uint_8 %uint_240 = OpConstant %uint 240 - %55 = OpConstantComposite %v3uint %uint_240 %uint_240 %uint_240 + %52 = OpConstantComposite %v3uint %uint_240 %uint_240 %uint_240 %uint_4 = OpConstant %uint 4 - %58 = OpConstantComposite %v3uint %uint_4 %uint_4 %uint_4 + %55 = OpConstantComposite %v3uint %uint_4 %uint_4 %uint_4 %uint_12 = OpConstant %uint 12 - %65 = OpConstantComposite %v3uint %uint_12 %uint_12 %uint_12 + %62 = OpConstantComposite %v3uint %uint_12 %uint_12 %uint_12 %uint_2 = OpConstant %uint 2 - %68 = OpConstantComposite %v3uint %uint_2 %uint_2 %uint_2 + %65 = OpConstantComposite %v3uint %uint_2 %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %76 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 + %73 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %uint_4294967295 = OpConstant %uint 4294967295 - %81 = OpConstantComposite %v3uint %uint_4294967295 %uint_4294967295 %uint_4294967295 + %78 = OpConstantComposite %v3uint %uint_4294967295 %uint_4294967295 %uint_4294967295 %void = OpTypeVoid - %88 = OpTypeFunction %void - %93 = OpConstantNull %v3int + %85 = OpTypeFunction %void %_ptr_Function_v3int = OpTypePointer Function %v3int - %96 = OpTypeFunction %v4float + %92 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_first_leading_bit = OpFunction %v3int None %9 %v = OpFunctionParameter %v3int %14 = OpLabel - %x = OpVariable %_ptr_Function_v3uint Function %28 - %20 = OpSLessThan %v3bool %v %19 - %24 = OpNot %v3int %v - %23 = OpBitcast %v3uint %24 - %25 = OpBitcast %v3uint %v - %15 = OpSelect %v3uint %20 %23 %25 + %x = OpVariable %_ptr_Function_v3uint Function %27 + %19 = OpSLessThan %v3bool %v %18 + %23 = OpNot %v3int %v + %22 = OpBitcast %v3uint %23 + %24 = OpBitcast %v3uint %v + %15 = OpSelect %v3uint %19 %22 %24 OpStore %x %15 - %31 = OpLoad %v3uint %x - %34 = OpBitwiseAnd %v3uint %31 %33 - %30 = OpINotEqual %v3bool %34 %28 - %29 = OpSelect %v3uint %30 %36 %38 - %39 = OpLoad %v3uint %x - %40 = OpShiftRightLogical %v3uint %39 %29 - OpStore %x %40 - %43 = OpLoad %v3uint %x - %46 = OpBitwiseAnd %v3uint %43 %45 - %42 = OpINotEqual %v3bool %46 %28 - %41 = OpSelect %v3uint %42 %48 %38 - %49 = OpLoad %v3uint %x - %50 = OpShiftRightLogical %v3uint %49 %41 - OpStore %x %50 - %53 = OpLoad %v3uint %x - %56 = OpBitwiseAnd %v3uint %53 %55 - %52 = OpINotEqual %v3bool %56 %28 - %51 = OpSelect %v3uint %52 %58 %38 - %59 = OpLoad %v3uint %x - %60 = OpShiftRightLogical %v3uint %59 %51 - OpStore %x %60 - %63 = OpLoad %v3uint %x - %66 = OpBitwiseAnd %v3uint %63 %65 - %62 = OpINotEqual %v3bool %66 %28 - %61 = OpSelect %v3uint %62 %68 %38 - %69 = OpLoad %v3uint %x - %70 = OpShiftRightLogical %v3uint %69 %61 - OpStore %x %70 - %73 = OpLoad %v3uint %x - %74 = OpBitwiseAnd %v3uint %73 %68 - %72 = OpINotEqual %v3bool %74 %28 - %71 = OpSelect %v3uint %72 %76 %38 - %78 = OpLoad %v3uint %x - %79 = OpIEqual %v3bool %78 %38 - %77 = OpSelect %v3uint %79 %81 %38 - %83 = OpBitwiseOr %v3uint %29 %41 - %84 = OpBitwiseOr %v3uint %83 %51 - %85 = OpBitwiseOr %v3uint %84 %61 - %86 = OpBitwiseOr %v3uint %85 %71 - %87 = OpBitwiseOr %v3uint %86 %77 - %82 = OpBitcast %v3int %87 - OpReturnValue %82 + %30 = OpLoad %v3uint %x + %33 = OpBitwiseAnd %v3uint %30 %32 + %29 = OpINotEqual %v3bool %33 %27 + %28 = OpSelect %v3uint %29 %35 %27 + %36 = OpLoad %v3uint %x + %37 = OpShiftRightLogical %v3uint %36 %28 + OpStore %x %37 + %40 = OpLoad %v3uint %x + %43 = OpBitwiseAnd %v3uint %40 %42 + %39 = OpINotEqual %v3bool %43 %27 + %38 = OpSelect %v3uint %39 %45 %27 + %46 = OpLoad %v3uint %x + %47 = OpShiftRightLogical %v3uint %46 %38 + OpStore %x %47 + %50 = OpLoad %v3uint %x + %53 = OpBitwiseAnd %v3uint %50 %52 + %49 = OpINotEqual %v3bool %53 %27 + %48 = OpSelect %v3uint %49 %55 %27 + %56 = OpLoad %v3uint %x + %57 = OpShiftRightLogical %v3uint %56 %48 + OpStore %x %57 + %60 = OpLoad %v3uint %x + %63 = OpBitwiseAnd %v3uint %60 %62 + %59 = OpINotEqual %v3bool %63 %27 + %58 = OpSelect %v3uint %59 %65 %27 + %66 = OpLoad %v3uint %x + %67 = OpShiftRightLogical %v3uint %66 %58 + OpStore %x %67 + %70 = OpLoad %v3uint %x + %71 = OpBitwiseAnd %v3uint %70 %65 + %69 = OpINotEqual %v3bool %71 %27 + %68 = OpSelect %v3uint %69 %73 %27 + %75 = OpLoad %v3uint %x + %76 = OpIEqual %v3bool %75 %27 + %74 = OpSelect %v3uint %76 %78 %27 + %80 = OpBitwiseOr %v3uint %28 %38 + %81 = OpBitwiseOr %v3uint %80 %48 + %82 = OpBitwiseOr %v3uint %81 %58 + %83 = OpBitwiseOr %v3uint %82 %68 + %84 = OpBitwiseOr %v3uint %83 %74 + %79 = OpBitcast %v3int %84 + OpReturnValue %79 OpFunctionEnd -%firstLeadingBit_35053e = OpFunction %void None %88 - %91 = OpLabel - %res = OpVariable %_ptr_Function_v3int Function %93 - %92 = OpFunctionCall %v3int %tint_first_leading_bit %93 - OpStore %res %92 +%firstLeadingBit_35053e = OpFunction %void None %85 + %88 = OpLabel + %res = OpVariable %_ptr_Function_v3int Function %18 + %89 = OpFunctionCall %v3int %tint_first_leading_bit %18 + OpStore %res %89 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %96 - %98 = OpLabel - %99 = OpFunctionCall %void %firstLeadingBit_35053e +%vertex_main_inner = OpFunction %v4float None %92 + %94 = OpLabel + %95 = OpFunctionCall %void %firstLeadingBit_35053e OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %88 - %101 = OpLabel - %102 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %102 +%vertex_main = OpFunction %void None %85 + %97 = OpLabel + %98 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %98 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %88 - %105 = OpLabel - %106 = OpFunctionCall %void %firstLeadingBit_35053e +%fragment_main = OpFunction %void None %85 + %101 = OpLabel + %102 = OpFunctionCall %void %firstLeadingBit_35053e OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %88 - %108 = OpLabel - %109 = OpFunctionCall %void %firstLeadingBit_35053e +%compute_main = OpFunction %void None %85 + %104 = OpLabel + %105 = OpFunctionCall %void %firstLeadingBit_35053e OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/firstLeadingBit/3fd7d0.wgsl.expected.spvasm b/test/tint/builtins/gen/firstLeadingBit/3fd7d0.wgsl.expected.spvasm index 28097dd28b..796a7f68c6 100644 --- a/test/tint/builtins/gen/firstLeadingBit/3fd7d0.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/firstLeadingBit/3fd7d0.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 99 +; Bound: 97 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -42,27 +42,25 @@ %24 = OpConstantComposite %v3uint %uint_4294901760 %uint_4294901760 %uint_4294901760 %uint_16 = OpConstant %uint 16 %27 = OpConstantComposite %v3uint %uint_16 %uint_16 %uint_16 - %uint_0 = OpConstant %uint 0 - %29 = OpConstantComposite %v3uint %uint_0 %uint_0 %uint_0 %uint_65280 = OpConstant %uint 65280 - %36 = OpConstantComposite %v3uint %uint_65280 %uint_65280 %uint_65280 + %34 = OpConstantComposite %v3uint %uint_65280 %uint_65280 %uint_65280 %uint_8 = OpConstant %uint 8 - %39 = OpConstantComposite %v3uint %uint_8 %uint_8 %uint_8 + %37 = OpConstantComposite %v3uint %uint_8 %uint_8 %uint_8 %uint_240 = OpConstant %uint 240 - %46 = OpConstantComposite %v3uint %uint_240 %uint_240 %uint_240 + %44 = OpConstantComposite %v3uint %uint_240 %uint_240 %uint_240 %uint_4 = OpConstant %uint 4 - %49 = OpConstantComposite %v3uint %uint_4 %uint_4 %uint_4 + %47 = OpConstantComposite %v3uint %uint_4 %uint_4 %uint_4 %uint_12 = OpConstant %uint 12 - %56 = OpConstantComposite %v3uint %uint_12 %uint_12 %uint_12 + %54 = OpConstantComposite %v3uint %uint_12 %uint_12 %uint_12 %uint_2 = OpConstant %uint 2 - %59 = OpConstantComposite %v3uint %uint_2 %uint_2 %uint_2 + %57 = OpConstantComposite %v3uint %uint_2 %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %67 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 + %65 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %uint_4294967295 = OpConstant %uint 4294967295 - %72 = OpConstantComposite %v3uint %uint_4294967295 %uint_4294967295 %uint_4294967295 + %70 = OpConstantComposite %v3uint %uint_4294967295 %uint_4294967295 %uint_4294967295 %void = OpTypeVoid - %79 = OpTypeFunction %void - %85 = OpTypeFunction %v4float + %77 = OpTypeFunction %void + %83 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_first_leading_bit = OpFunction %v3uint None %9 %v = OpFunctionParameter %v3uint @@ -72,71 +70,71 @@ %22 = OpLoad %v3uint %x %25 = OpBitwiseAnd %v3uint %22 %24 %19 = OpINotEqual %v3bool %25 %17 - %18 = OpSelect %v3uint %19 %27 %29 - %30 = OpLoad %v3uint %x - %31 = OpShiftRightLogical %v3uint %30 %18 - OpStore %x %31 - %34 = OpLoad %v3uint %x - %37 = OpBitwiseAnd %v3uint %34 %36 - %33 = OpINotEqual %v3bool %37 %17 - %32 = OpSelect %v3uint %33 %39 %29 - %40 = OpLoad %v3uint %x - %41 = OpShiftRightLogical %v3uint %40 %32 - OpStore %x %41 - %44 = OpLoad %v3uint %x - %47 = OpBitwiseAnd %v3uint %44 %46 - %43 = OpINotEqual %v3bool %47 %17 - %42 = OpSelect %v3uint %43 %49 %29 - %50 = OpLoad %v3uint %x - %51 = OpShiftRightLogical %v3uint %50 %42 - OpStore %x %51 - %54 = OpLoad %v3uint %x - %57 = OpBitwiseAnd %v3uint %54 %56 - %53 = OpINotEqual %v3bool %57 %17 - %52 = OpSelect %v3uint %53 %59 %29 - %60 = OpLoad %v3uint %x - %61 = OpShiftRightLogical %v3uint %60 %52 - OpStore %x %61 - %64 = OpLoad %v3uint %x - %65 = OpBitwiseAnd %v3uint %64 %59 - %63 = OpINotEqual %v3bool %65 %17 - %62 = OpSelect %v3uint %63 %67 %29 - %69 = OpLoad %v3uint %x - %70 = OpIEqual %v3bool %69 %29 - %68 = OpSelect %v3uint %70 %72 %29 - %74 = OpBitwiseOr %v3uint %18 %32 - %75 = OpBitwiseOr %v3uint %74 %42 - %76 = OpBitwiseOr %v3uint %75 %52 - %77 = OpBitwiseOr %v3uint %76 %62 - %78 = OpBitwiseOr %v3uint %77 %68 - OpReturnValue %78 + %18 = OpSelect %v3uint %19 %27 %17 + %28 = OpLoad %v3uint %x + %29 = OpShiftRightLogical %v3uint %28 %18 + OpStore %x %29 + %32 = OpLoad %v3uint %x + %35 = OpBitwiseAnd %v3uint %32 %34 + %31 = OpINotEqual %v3bool %35 %17 + %30 = OpSelect %v3uint %31 %37 %17 + %38 = OpLoad %v3uint %x + %39 = OpShiftRightLogical %v3uint %38 %30 + OpStore %x %39 + %42 = OpLoad %v3uint %x + %45 = OpBitwiseAnd %v3uint %42 %44 + %41 = OpINotEqual %v3bool %45 %17 + %40 = OpSelect %v3uint %41 %47 %17 + %48 = OpLoad %v3uint %x + %49 = OpShiftRightLogical %v3uint %48 %40 + OpStore %x %49 + %52 = OpLoad %v3uint %x + %55 = OpBitwiseAnd %v3uint %52 %54 + %51 = OpINotEqual %v3bool %55 %17 + %50 = OpSelect %v3uint %51 %57 %17 + %58 = OpLoad %v3uint %x + %59 = OpShiftRightLogical %v3uint %58 %50 + OpStore %x %59 + %62 = OpLoad %v3uint %x + %63 = OpBitwiseAnd %v3uint %62 %57 + %61 = OpINotEqual %v3bool %63 %17 + %60 = OpSelect %v3uint %61 %65 %17 + %67 = OpLoad %v3uint %x + %68 = OpIEqual %v3bool %67 %17 + %66 = OpSelect %v3uint %68 %70 %17 + %72 = OpBitwiseOr %v3uint %18 %30 + %73 = OpBitwiseOr %v3uint %72 %40 + %74 = OpBitwiseOr %v3uint %73 %50 + %75 = OpBitwiseOr %v3uint %74 %60 + %76 = OpBitwiseOr %v3uint %75 %66 + OpReturnValue %76 OpFunctionEnd -%firstLeadingBit_3fd7d0 = OpFunction %void None %79 - %82 = OpLabel +%firstLeadingBit_3fd7d0 = OpFunction %void None %77 + %80 = OpLabel %res = OpVariable %_ptr_Function_v3uint Function %17 - %83 = OpFunctionCall %v3uint %tint_first_leading_bit %17 - OpStore %res %83 + %81 = OpFunctionCall %v3uint %tint_first_leading_bit %17 + OpStore %res %81 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %85 - %87 = OpLabel - %88 = OpFunctionCall %void %firstLeadingBit_3fd7d0 +%vertex_main_inner = OpFunction %v4float None %83 + %85 = OpLabel + %86 = OpFunctionCall %void %firstLeadingBit_3fd7d0 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %79 - %90 = OpLabel - %91 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %91 +%vertex_main = OpFunction %void None %77 + %88 = OpLabel + %89 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %89 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %79 - %94 = OpLabel - %95 = OpFunctionCall %void %firstLeadingBit_3fd7d0 +%fragment_main = OpFunction %void None %77 + %92 = OpLabel + %93 = OpFunctionCall %void %firstLeadingBit_3fd7d0 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %79 - %97 = OpLabel - %98 = OpFunctionCall %void %firstLeadingBit_3fd7d0 +%compute_main = OpFunction %void None %77 + %95 = OpLabel + %96 = OpFunctionCall %void %firstLeadingBit_3fd7d0 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/firstLeadingBit/57a1a3.wgsl.expected.spvasm b/test/tint/builtins/gen/firstLeadingBit/57a1a3.wgsl.expected.spvasm index bea47c79ed..fea9df7622 100644 --- a/test/tint/builtins/gen/firstLeadingBit/57a1a3.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/firstLeadingBit/57a1a3.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 96 +; Bound: 94 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -34,13 +34,12 @@ %int = OpTypeInt 32 1 %9 = OpTypeFunction %int %int %uint = OpTypeInt 32 0 - %int_0 = OpConstant %int 0 + %16 = OpConstantNull %int %bool = OpTypeBool %_ptr_Function_uint = OpTypePointer Function %uint %24 = OpConstantNull %uint %uint_4294901760 = OpConstant %uint 4294901760 %uint_16 = OpConstant %uint 16 - %uint_0 = OpConstant %uint 0 %uint_65280 = OpConstant %uint 65280 %uint_8 = OpConstant %uint 8 %uint_240 = OpConstant %uint 240 @@ -50,17 +49,16 @@ %uint_1 = OpConstant %uint 1 %uint_4294967295 = OpConstant %uint 4294967295 %void = OpTypeVoid - %73 = OpTypeFunction %void + %72 = OpTypeFunction %void %int_1 = OpConstant %int 1 %_ptr_Function_int = OpTypePointer Function %int - %81 = OpConstantNull %int - %82 = OpTypeFunction %v4float + %80 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_first_leading_bit = OpFunction %int None %9 %v = OpFunctionParameter %int %13 = OpLabel %x = OpVariable %_ptr_Function_uint Function %24 - %17 = OpSLessThan %bool %v %int_0 + %17 = OpSLessThan %bool %v %16 %20 = OpNot %int %v %19 = OpBitcast %uint %20 %21 = OpBitcast %uint %v @@ -69,72 +67,72 @@ %27 = OpLoad %uint %x %29 = OpBitwiseAnd %uint %27 %uint_4294901760 %26 = OpINotEqual %bool %29 %24 - %25 = OpSelect %uint %26 %uint_16 %uint_0 - %32 = OpLoad %uint %x - %33 = OpShiftRightLogical %uint %32 %25 - OpStore %x %33 - %36 = OpLoad %uint %x - %38 = OpBitwiseAnd %uint %36 %uint_65280 - %35 = OpINotEqual %bool %38 %24 - %34 = OpSelect %uint %35 %uint_8 %uint_0 - %40 = OpLoad %uint %x - %41 = OpShiftRightLogical %uint %40 %34 - OpStore %x %41 - %44 = OpLoad %uint %x - %46 = OpBitwiseAnd %uint %44 %uint_240 - %43 = OpINotEqual %bool %46 %24 - %42 = OpSelect %uint %43 %uint_4 %uint_0 - %48 = OpLoad %uint %x - %49 = OpShiftRightLogical %uint %48 %42 - OpStore %x %49 - %52 = OpLoad %uint %x - %54 = OpBitwiseAnd %uint %52 %uint_12 - %51 = OpINotEqual %bool %54 %24 - %50 = OpSelect %uint %51 %uint_2 %uint_0 - %56 = OpLoad %uint %x - %57 = OpShiftRightLogical %uint %56 %50 - OpStore %x %57 - %60 = OpLoad %uint %x - %61 = OpBitwiseAnd %uint %60 %uint_2 - %59 = OpINotEqual %bool %61 %24 - %58 = OpSelect %uint %59 %uint_1 %uint_0 - %64 = OpLoad %uint %x - %65 = OpIEqual %bool %64 %uint_0 - %63 = OpSelect %uint %65 %uint_4294967295 %uint_0 - %68 = OpBitwiseOr %uint %25 %34 - %69 = OpBitwiseOr %uint %68 %42 - %70 = OpBitwiseOr %uint %69 %50 - %71 = OpBitwiseOr %uint %70 %58 - %72 = OpBitwiseOr %uint %71 %63 - %67 = OpBitcast %int %72 - OpReturnValue %67 + %25 = OpSelect %uint %26 %uint_16 %24 + %31 = OpLoad %uint %x + %32 = OpShiftRightLogical %uint %31 %25 + OpStore %x %32 + %35 = OpLoad %uint %x + %37 = OpBitwiseAnd %uint %35 %uint_65280 + %34 = OpINotEqual %bool %37 %24 + %33 = OpSelect %uint %34 %uint_8 %24 + %39 = OpLoad %uint %x + %40 = OpShiftRightLogical %uint %39 %33 + OpStore %x %40 + %43 = OpLoad %uint %x + %45 = OpBitwiseAnd %uint %43 %uint_240 + %42 = OpINotEqual %bool %45 %24 + %41 = OpSelect %uint %42 %uint_4 %24 + %47 = OpLoad %uint %x + %48 = OpShiftRightLogical %uint %47 %41 + OpStore %x %48 + %51 = OpLoad %uint %x + %53 = OpBitwiseAnd %uint %51 %uint_12 + %50 = OpINotEqual %bool %53 %24 + %49 = OpSelect %uint %50 %uint_2 %24 + %55 = OpLoad %uint %x + %56 = OpShiftRightLogical %uint %55 %49 + OpStore %x %56 + %59 = OpLoad %uint %x + %60 = OpBitwiseAnd %uint %59 %uint_2 + %58 = OpINotEqual %bool %60 %24 + %57 = OpSelect %uint %58 %uint_1 %24 + %63 = OpLoad %uint %x + %64 = OpIEqual %bool %63 %24 + %62 = OpSelect %uint %64 %uint_4294967295 %24 + %67 = OpBitwiseOr %uint %25 %33 + %68 = OpBitwiseOr %uint %67 %41 + %69 = OpBitwiseOr %uint %68 %49 + %70 = OpBitwiseOr %uint %69 %57 + %71 = OpBitwiseOr %uint %70 %62 + %66 = OpBitcast %int %71 + OpReturnValue %66 OpFunctionEnd -%firstLeadingBit_57a1a3 = OpFunction %void None %73 - %76 = OpLabel - %res = OpVariable %_ptr_Function_int Function %81 - %77 = OpFunctionCall %int %tint_first_leading_bit %int_1 - OpStore %res %77 +%firstLeadingBit_57a1a3 = OpFunction %void None %72 + %75 = OpLabel + %res = OpVariable %_ptr_Function_int Function %16 + %76 = OpFunctionCall %int %tint_first_leading_bit %int_1 + OpStore %res %76 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %82 - %84 = OpLabel - %85 = OpFunctionCall %void %firstLeadingBit_57a1a3 +%vertex_main_inner = OpFunction %v4float None %80 + %82 = OpLabel + %83 = OpFunctionCall %void %firstLeadingBit_57a1a3 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %73 - %87 = OpLabel - %88 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %88 +%vertex_main = OpFunction %void None %72 + %85 = OpLabel + %86 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %86 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %73 - %91 = OpLabel - %92 = OpFunctionCall %void %firstLeadingBit_57a1a3 +%fragment_main = OpFunction %void None %72 + %89 = OpLabel + %90 = OpFunctionCall %void %firstLeadingBit_57a1a3 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %73 - %94 = OpLabel - %95 = OpFunctionCall %void %firstLeadingBit_57a1a3 +%compute_main = OpFunction %void None %72 + %92 = OpLabel + %93 = OpFunctionCall %void %firstLeadingBit_57a1a3 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/firstLeadingBit/6fe804.wgsl.expected.spvasm b/test/tint/builtins/gen/firstLeadingBit/6fe804.wgsl.expected.spvasm index 399a3d1969..b5b8dc3621 100644 --- a/test/tint/builtins/gen/firstLeadingBit/6fe804.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/firstLeadingBit/6fe804.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 99 +; Bound: 97 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -42,27 +42,25 @@ %24 = OpConstantComposite %v2uint %uint_4294901760 %uint_4294901760 %uint_16 = OpConstant %uint 16 %27 = OpConstantComposite %v2uint %uint_16 %uint_16 - %uint_0 = OpConstant %uint 0 - %29 = OpConstantComposite %v2uint %uint_0 %uint_0 %uint_65280 = OpConstant %uint 65280 - %36 = OpConstantComposite %v2uint %uint_65280 %uint_65280 + %34 = OpConstantComposite %v2uint %uint_65280 %uint_65280 %uint_8 = OpConstant %uint 8 - %39 = OpConstantComposite %v2uint %uint_8 %uint_8 + %37 = OpConstantComposite %v2uint %uint_8 %uint_8 %uint_240 = OpConstant %uint 240 - %46 = OpConstantComposite %v2uint %uint_240 %uint_240 + %44 = OpConstantComposite %v2uint %uint_240 %uint_240 %uint_4 = OpConstant %uint 4 - %49 = OpConstantComposite %v2uint %uint_4 %uint_4 + %47 = OpConstantComposite %v2uint %uint_4 %uint_4 %uint_12 = OpConstant %uint 12 - %56 = OpConstantComposite %v2uint %uint_12 %uint_12 + %54 = OpConstantComposite %v2uint %uint_12 %uint_12 %uint_2 = OpConstant %uint 2 - %59 = OpConstantComposite %v2uint %uint_2 %uint_2 + %57 = OpConstantComposite %v2uint %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %67 = OpConstantComposite %v2uint %uint_1 %uint_1 + %65 = OpConstantComposite %v2uint %uint_1 %uint_1 %uint_4294967295 = OpConstant %uint 4294967295 - %72 = OpConstantComposite %v2uint %uint_4294967295 %uint_4294967295 + %70 = OpConstantComposite %v2uint %uint_4294967295 %uint_4294967295 %void = OpTypeVoid - %79 = OpTypeFunction %void - %85 = OpTypeFunction %v4float + %77 = OpTypeFunction %void + %83 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_first_leading_bit = OpFunction %v2uint None %9 %v = OpFunctionParameter %v2uint @@ -72,71 +70,71 @@ %22 = OpLoad %v2uint %x %25 = OpBitwiseAnd %v2uint %22 %24 %19 = OpINotEqual %v2bool %25 %17 - %18 = OpSelect %v2uint %19 %27 %29 - %30 = OpLoad %v2uint %x - %31 = OpShiftRightLogical %v2uint %30 %18 - OpStore %x %31 - %34 = OpLoad %v2uint %x - %37 = OpBitwiseAnd %v2uint %34 %36 - %33 = OpINotEqual %v2bool %37 %17 - %32 = OpSelect %v2uint %33 %39 %29 - %40 = OpLoad %v2uint %x - %41 = OpShiftRightLogical %v2uint %40 %32 - OpStore %x %41 - %44 = OpLoad %v2uint %x - %47 = OpBitwiseAnd %v2uint %44 %46 - %43 = OpINotEqual %v2bool %47 %17 - %42 = OpSelect %v2uint %43 %49 %29 - %50 = OpLoad %v2uint %x - %51 = OpShiftRightLogical %v2uint %50 %42 - OpStore %x %51 - %54 = OpLoad %v2uint %x - %57 = OpBitwiseAnd %v2uint %54 %56 - %53 = OpINotEqual %v2bool %57 %17 - %52 = OpSelect %v2uint %53 %59 %29 - %60 = OpLoad %v2uint %x - %61 = OpShiftRightLogical %v2uint %60 %52 - OpStore %x %61 - %64 = OpLoad %v2uint %x - %65 = OpBitwiseAnd %v2uint %64 %59 - %63 = OpINotEqual %v2bool %65 %17 - %62 = OpSelect %v2uint %63 %67 %29 - %69 = OpLoad %v2uint %x - %70 = OpIEqual %v2bool %69 %29 - %68 = OpSelect %v2uint %70 %72 %29 - %74 = OpBitwiseOr %v2uint %18 %32 - %75 = OpBitwiseOr %v2uint %74 %42 - %76 = OpBitwiseOr %v2uint %75 %52 - %77 = OpBitwiseOr %v2uint %76 %62 - %78 = OpBitwiseOr %v2uint %77 %68 - OpReturnValue %78 + %18 = OpSelect %v2uint %19 %27 %17 + %28 = OpLoad %v2uint %x + %29 = OpShiftRightLogical %v2uint %28 %18 + OpStore %x %29 + %32 = OpLoad %v2uint %x + %35 = OpBitwiseAnd %v2uint %32 %34 + %31 = OpINotEqual %v2bool %35 %17 + %30 = OpSelect %v2uint %31 %37 %17 + %38 = OpLoad %v2uint %x + %39 = OpShiftRightLogical %v2uint %38 %30 + OpStore %x %39 + %42 = OpLoad %v2uint %x + %45 = OpBitwiseAnd %v2uint %42 %44 + %41 = OpINotEqual %v2bool %45 %17 + %40 = OpSelect %v2uint %41 %47 %17 + %48 = OpLoad %v2uint %x + %49 = OpShiftRightLogical %v2uint %48 %40 + OpStore %x %49 + %52 = OpLoad %v2uint %x + %55 = OpBitwiseAnd %v2uint %52 %54 + %51 = OpINotEqual %v2bool %55 %17 + %50 = OpSelect %v2uint %51 %57 %17 + %58 = OpLoad %v2uint %x + %59 = OpShiftRightLogical %v2uint %58 %50 + OpStore %x %59 + %62 = OpLoad %v2uint %x + %63 = OpBitwiseAnd %v2uint %62 %57 + %61 = OpINotEqual %v2bool %63 %17 + %60 = OpSelect %v2uint %61 %65 %17 + %67 = OpLoad %v2uint %x + %68 = OpIEqual %v2bool %67 %17 + %66 = OpSelect %v2uint %68 %70 %17 + %72 = OpBitwiseOr %v2uint %18 %30 + %73 = OpBitwiseOr %v2uint %72 %40 + %74 = OpBitwiseOr %v2uint %73 %50 + %75 = OpBitwiseOr %v2uint %74 %60 + %76 = OpBitwiseOr %v2uint %75 %66 + OpReturnValue %76 OpFunctionEnd -%firstLeadingBit_6fe804 = OpFunction %void None %79 - %82 = OpLabel +%firstLeadingBit_6fe804 = OpFunction %void None %77 + %80 = OpLabel %res = OpVariable %_ptr_Function_v2uint Function %17 - %83 = OpFunctionCall %v2uint %tint_first_leading_bit %17 - OpStore %res %83 + %81 = OpFunctionCall %v2uint %tint_first_leading_bit %17 + OpStore %res %81 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %85 - %87 = OpLabel - %88 = OpFunctionCall %void %firstLeadingBit_6fe804 +%vertex_main_inner = OpFunction %v4float None %83 + %85 = OpLabel + %86 = OpFunctionCall %void %firstLeadingBit_6fe804 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %79 - %90 = OpLabel - %91 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %91 +%vertex_main = OpFunction %void None %77 + %88 = OpLabel + %89 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %89 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %79 - %94 = OpLabel - %95 = OpFunctionCall %void %firstLeadingBit_6fe804 +%fragment_main = OpFunction %void None %77 + %92 = OpLabel + %93 = OpFunctionCall %void %firstLeadingBit_6fe804 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %79 - %97 = OpLabel - %98 = OpFunctionCall %void %firstLeadingBit_6fe804 +%compute_main = OpFunction %void None %77 + %95 = OpLabel + %96 = OpFunctionCall %void %firstLeadingBit_6fe804 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/firstLeadingBit/a622c2.wgsl.expected.spvasm b/test/tint/builtins/gen/firstLeadingBit/a622c2.wgsl.expected.spvasm index 3f27c360ca..c50c83d530 100644 --- a/test/tint/builtins/gen/firstLeadingBit/a622c2.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/firstLeadingBit/a622c2.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 110 +; Bound: 106 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -36,119 +36,115 @@ %9 = OpTypeFunction %v2int %v2int %uint = OpTypeInt 32 0 %v2uint = OpTypeVector %uint 2 - %int_0 = OpConstant %int 0 - %19 = OpConstantComposite %v2int %int_0 %int_0 + %18 = OpConstantNull %v2int %bool = OpTypeBool %v2bool = OpTypeVector %bool 2 %_ptr_Function_v2uint = OpTypePointer Function %v2uint - %28 = OpConstantNull %v2uint + %27 = OpConstantNull %v2uint %uint_4294901760 = OpConstant %uint 4294901760 - %33 = OpConstantComposite %v2uint %uint_4294901760 %uint_4294901760 + %32 = OpConstantComposite %v2uint %uint_4294901760 %uint_4294901760 %uint_16 = OpConstant %uint 16 - %36 = OpConstantComposite %v2uint %uint_16 %uint_16 - %uint_0 = OpConstant %uint 0 - %38 = OpConstantComposite %v2uint %uint_0 %uint_0 + %35 = OpConstantComposite %v2uint %uint_16 %uint_16 %uint_65280 = OpConstant %uint 65280 - %45 = OpConstantComposite %v2uint %uint_65280 %uint_65280 + %42 = OpConstantComposite %v2uint %uint_65280 %uint_65280 %uint_8 = OpConstant %uint 8 - %48 = OpConstantComposite %v2uint %uint_8 %uint_8 + %45 = OpConstantComposite %v2uint %uint_8 %uint_8 %uint_240 = OpConstant %uint 240 - %55 = OpConstantComposite %v2uint %uint_240 %uint_240 + %52 = OpConstantComposite %v2uint %uint_240 %uint_240 %uint_4 = OpConstant %uint 4 - %58 = OpConstantComposite %v2uint %uint_4 %uint_4 + %55 = OpConstantComposite %v2uint %uint_4 %uint_4 %uint_12 = OpConstant %uint 12 - %65 = OpConstantComposite %v2uint %uint_12 %uint_12 + %62 = OpConstantComposite %v2uint %uint_12 %uint_12 %uint_2 = OpConstant %uint 2 - %68 = OpConstantComposite %v2uint %uint_2 %uint_2 + %65 = OpConstantComposite %v2uint %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %76 = OpConstantComposite %v2uint %uint_1 %uint_1 + %73 = OpConstantComposite %v2uint %uint_1 %uint_1 %uint_4294967295 = OpConstant %uint 4294967295 - %81 = OpConstantComposite %v2uint %uint_4294967295 %uint_4294967295 + %78 = OpConstantComposite %v2uint %uint_4294967295 %uint_4294967295 %void = OpTypeVoid - %88 = OpTypeFunction %void - %93 = OpConstantNull %v2int + %85 = OpTypeFunction %void %_ptr_Function_v2int = OpTypePointer Function %v2int - %96 = OpTypeFunction %v4float + %92 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_first_leading_bit = OpFunction %v2int None %9 %v = OpFunctionParameter %v2int %14 = OpLabel - %x = OpVariable %_ptr_Function_v2uint Function %28 - %20 = OpSLessThan %v2bool %v %19 - %24 = OpNot %v2int %v - %23 = OpBitcast %v2uint %24 - %25 = OpBitcast %v2uint %v - %15 = OpSelect %v2uint %20 %23 %25 + %x = OpVariable %_ptr_Function_v2uint Function %27 + %19 = OpSLessThan %v2bool %v %18 + %23 = OpNot %v2int %v + %22 = OpBitcast %v2uint %23 + %24 = OpBitcast %v2uint %v + %15 = OpSelect %v2uint %19 %22 %24 OpStore %x %15 - %31 = OpLoad %v2uint %x - %34 = OpBitwiseAnd %v2uint %31 %33 - %30 = OpINotEqual %v2bool %34 %28 - %29 = OpSelect %v2uint %30 %36 %38 - %39 = OpLoad %v2uint %x - %40 = OpShiftRightLogical %v2uint %39 %29 - OpStore %x %40 - %43 = OpLoad %v2uint %x - %46 = OpBitwiseAnd %v2uint %43 %45 - %42 = OpINotEqual %v2bool %46 %28 - %41 = OpSelect %v2uint %42 %48 %38 - %49 = OpLoad %v2uint %x - %50 = OpShiftRightLogical %v2uint %49 %41 - OpStore %x %50 - %53 = OpLoad %v2uint %x - %56 = OpBitwiseAnd %v2uint %53 %55 - %52 = OpINotEqual %v2bool %56 %28 - %51 = OpSelect %v2uint %52 %58 %38 - %59 = OpLoad %v2uint %x - %60 = OpShiftRightLogical %v2uint %59 %51 - OpStore %x %60 - %63 = OpLoad %v2uint %x - %66 = OpBitwiseAnd %v2uint %63 %65 - %62 = OpINotEqual %v2bool %66 %28 - %61 = OpSelect %v2uint %62 %68 %38 - %69 = OpLoad %v2uint %x - %70 = OpShiftRightLogical %v2uint %69 %61 - OpStore %x %70 - %73 = OpLoad %v2uint %x - %74 = OpBitwiseAnd %v2uint %73 %68 - %72 = OpINotEqual %v2bool %74 %28 - %71 = OpSelect %v2uint %72 %76 %38 - %78 = OpLoad %v2uint %x - %79 = OpIEqual %v2bool %78 %38 - %77 = OpSelect %v2uint %79 %81 %38 - %83 = OpBitwiseOr %v2uint %29 %41 - %84 = OpBitwiseOr %v2uint %83 %51 - %85 = OpBitwiseOr %v2uint %84 %61 - %86 = OpBitwiseOr %v2uint %85 %71 - %87 = OpBitwiseOr %v2uint %86 %77 - %82 = OpBitcast %v2int %87 - OpReturnValue %82 + %30 = OpLoad %v2uint %x + %33 = OpBitwiseAnd %v2uint %30 %32 + %29 = OpINotEqual %v2bool %33 %27 + %28 = OpSelect %v2uint %29 %35 %27 + %36 = OpLoad %v2uint %x + %37 = OpShiftRightLogical %v2uint %36 %28 + OpStore %x %37 + %40 = OpLoad %v2uint %x + %43 = OpBitwiseAnd %v2uint %40 %42 + %39 = OpINotEqual %v2bool %43 %27 + %38 = OpSelect %v2uint %39 %45 %27 + %46 = OpLoad %v2uint %x + %47 = OpShiftRightLogical %v2uint %46 %38 + OpStore %x %47 + %50 = OpLoad %v2uint %x + %53 = OpBitwiseAnd %v2uint %50 %52 + %49 = OpINotEqual %v2bool %53 %27 + %48 = OpSelect %v2uint %49 %55 %27 + %56 = OpLoad %v2uint %x + %57 = OpShiftRightLogical %v2uint %56 %48 + OpStore %x %57 + %60 = OpLoad %v2uint %x + %63 = OpBitwiseAnd %v2uint %60 %62 + %59 = OpINotEqual %v2bool %63 %27 + %58 = OpSelect %v2uint %59 %65 %27 + %66 = OpLoad %v2uint %x + %67 = OpShiftRightLogical %v2uint %66 %58 + OpStore %x %67 + %70 = OpLoad %v2uint %x + %71 = OpBitwiseAnd %v2uint %70 %65 + %69 = OpINotEqual %v2bool %71 %27 + %68 = OpSelect %v2uint %69 %73 %27 + %75 = OpLoad %v2uint %x + %76 = OpIEqual %v2bool %75 %27 + %74 = OpSelect %v2uint %76 %78 %27 + %80 = OpBitwiseOr %v2uint %28 %38 + %81 = OpBitwiseOr %v2uint %80 %48 + %82 = OpBitwiseOr %v2uint %81 %58 + %83 = OpBitwiseOr %v2uint %82 %68 + %84 = OpBitwiseOr %v2uint %83 %74 + %79 = OpBitcast %v2int %84 + OpReturnValue %79 OpFunctionEnd -%firstLeadingBit_a622c2 = OpFunction %void None %88 - %91 = OpLabel - %res = OpVariable %_ptr_Function_v2int Function %93 - %92 = OpFunctionCall %v2int %tint_first_leading_bit %93 - OpStore %res %92 +%firstLeadingBit_a622c2 = OpFunction %void None %85 + %88 = OpLabel + %res = OpVariable %_ptr_Function_v2int Function %18 + %89 = OpFunctionCall %v2int %tint_first_leading_bit %18 + OpStore %res %89 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %96 - %98 = OpLabel - %99 = OpFunctionCall %void %firstLeadingBit_a622c2 +%vertex_main_inner = OpFunction %v4float None %92 + %94 = OpLabel + %95 = OpFunctionCall %void %firstLeadingBit_a622c2 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %88 - %101 = OpLabel - %102 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %102 +%vertex_main = OpFunction %void None %85 + %97 = OpLabel + %98 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %98 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %88 - %105 = OpLabel - %106 = OpFunctionCall %void %firstLeadingBit_a622c2 +%fragment_main = OpFunction %void None %85 + %101 = OpLabel + %102 = OpFunctionCall %void %firstLeadingBit_a622c2 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %88 - %108 = OpLabel - %109 = OpFunctionCall %void %firstLeadingBit_a622c2 +%compute_main = OpFunction %void None %85 + %104 = OpLabel + %105 = OpFunctionCall %void %firstLeadingBit_a622c2 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/firstLeadingBit/c1f940.wgsl.expected.spvasm b/test/tint/builtins/gen/firstLeadingBit/c1f940.wgsl.expected.spvasm index 280467959c..ef84d93b7c 100644 --- a/test/tint/builtins/gen/firstLeadingBit/c1f940.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/firstLeadingBit/c1f940.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 110 +; Bound: 106 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -36,119 +36,115 @@ %9 = OpTypeFunction %v4int %v4int %uint = OpTypeInt 32 0 %v4uint = OpTypeVector %uint 4 - %int_0 = OpConstant %int 0 - %19 = OpConstantComposite %v4int %int_0 %int_0 %int_0 %int_0 + %18 = OpConstantNull %v4int %bool = OpTypeBool %v4bool = OpTypeVector %bool 4 %_ptr_Function_v4uint = OpTypePointer Function %v4uint - %28 = OpConstantNull %v4uint + %27 = OpConstantNull %v4uint %uint_4294901760 = OpConstant %uint 4294901760 - %33 = OpConstantComposite %v4uint %uint_4294901760 %uint_4294901760 %uint_4294901760 %uint_4294901760 + %32 = OpConstantComposite %v4uint %uint_4294901760 %uint_4294901760 %uint_4294901760 %uint_4294901760 %uint_16 = OpConstant %uint 16 - %36 = OpConstantComposite %v4uint %uint_16 %uint_16 %uint_16 %uint_16 - %uint_0 = OpConstant %uint 0 - %38 = OpConstantComposite %v4uint %uint_0 %uint_0 %uint_0 %uint_0 + %35 = OpConstantComposite %v4uint %uint_16 %uint_16 %uint_16 %uint_16 %uint_65280 = OpConstant %uint 65280 - %45 = OpConstantComposite %v4uint %uint_65280 %uint_65280 %uint_65280 %uint_65280 + %42 = OpConstantComposite %v4uint %uint_65280 %uint_65280 %uint_65280 %uint_65280 %uint_8 = OpConstant %uint 8 - %48 = OpConstantComposite %v4uint %uint_8 %uint_8 %uint_8 %uint_8 + %45 = OpConstantComposite %v4uint %uint_8 %uint_8 %uint_8 %uint_8 %uint_240 = OpConstant %uint 240 - %55 = OpConstantComposite %v4uint %uint_240 %uint_240 %uint_240 %uint_240 + %52 = OpConstantComposite %v4uint %uint_240 %uint_240 %uint_240 %uint_240 %uint_4 = OpConstant %uint 4 - %58 = OpConstantComposite %v4uint %uint_4 %uint_4 %uint_4 %uint_4 + %55 = OpConstantComposite %v4uint %uint_4 %uint_4 %uint_4 %uint_4 %uint_12 = OpConstant %uint 12 - %65 = OpConstantComposite %v4uint %uint_12 %uint_12 %uint_12 %uint_12 + %62 = OpConstantComposite %v4uint %uint_12 %uint_12 %uint_12 %uint_12 %uint_2 = OpConstant %uint 2 - %68 = OpConstantComposite %v4uint %uint_2 %uint_2 %uint_2 %uint_2 + %65 = OpConstantComposite %v4uint %uint_2 %uint_2 %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %76 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 + %73 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 %uint_4294967295 = OpConstant %uint 4294967295 - %81 = OpConstantComposite %v4uint %uint_4294967295 %uint_4294967295 %uint_4294967295 %uint_4294967295 + %78 = OpConstantComposite %v4uint %uint_4294967295 %uint_4294967295 %uint_4294967295 %uint_4294967295 %void = OpTypeVoid - %88 = OpTypeFunction %void - %93 = OpConstantNull %v4int + %85 = OpTypeFunction %void %_ptr_Function_v4int = OpTypePointer Function %v4int - %96 = OpTypeFunction %v4float + %92 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_first_leading_bit = OpFunction %v4int None %9 %v = OpFunctionParameter %v4int %14 = OpLabel - %x = OpVariable %_ptr_Function_v4uint Function %28 - %20 = OpSLessThan %v4bool %v %19 - %24 = OpNot %v4int %v - %23 = OpBitcast %v4uint %24 - %25 = OpBitcast %v4uint %v - %15 = OpSelect %v4uint %20 %23 %25 + %x = OpVariable %_ptr_Function_v4uint Function %27 + %19 = OpSLessThan %v4bool %v %18 + %23 = OpNot %v4int %v + %22 = OpBitcast %v4uint %23 + %24 = OpBitcast %v4uint %v + %15 = OpSelect %v4uint %19 %22 %24 OpStore %x %15 - %31 = OpLoad %v4uint %x - %34 = OpBitwiseAnd %v4uint %31 %33 - %30 = OpINotEqual %v4bool %34 %28 - %29 = OpSelect %v4uint %30 %36 %38 - %39 = OpLoad %v4uint %x - %40 = OpShiftRightLogical %v4uint %39 %29 - OpStore %x %40 - %43 = OpLoad %v4uint %x - %46 = OpBitwiseAnd %v4uint %43 %45 - %42 = OpINotEqual %v4bool %46 %28 - %41 = OpSelect %v4uint %42 %48 %38 - %49 = OpLoad %v4uint %x - %50 = OpShiftRightLogical %v4uint %49 %41 - OpStore %x %50 - %53 = OpLoad %v4uint %x - %56 = OpBitwiseAnd %v4uint %53 %55 - %52 = OpINotEqual %v4bool %56 %28 - %51 = OpSelect %v4uint %52 %58 %38 - %59 = OpLoad %v4uint %x - %60 = OpShiftRightLogical %v4uint %59 %51 - OpStore %x %60 - %63 = OpLoad %v4uint %x - %66 = OpBitwiseAnd %v4uint %63 %65 - %62 = OpINotEqual %v4bool %66 %28 - %61 = OpSelect %v4uint %62 %68 %38 - %69 = OpLoad %v4uint %x - %70 = OpShiftRightLogical %v4uint %69 %61 - OpStore %x %70 - %73 = OpLoad %v4uint %x - %74 = OpBitwiseAnd %v4uint %73 %68 - %72 = OpINotEqual %v4bool %74 %28 - %71 = OpSelect %v4uint %72 %76 %38 - %78 = OpLoad %v4uint %x - %79 = OpIEqual %v4bool %78 %38 - %77 = OpSelect %v4uint %79 %81 %38 - %83 = OpBitwiseOr %v4uint %29 %41 - %84 = OpBitwiseOr %v4uint %83 %51 - %85 = OpBitwiseOr %v4uint %84 %61 - %86 = OpBitwiseOr %v4uint %85 %71 - %87 = OpBitwiseOr %v4uint %86 %77 - %82 = OpBitcast %v4int %87 - OpReturnValue %82 + %30 = OpLoad %v4uint %x + %33 = OpBitwiseAnd %v4uint %30 %32 + %29 = OpINotEqual %v4bool %33 %27 + %28 = OpSelect %v4uint %29 %35 %27 + %36 = OpLoad %v4uint %x + %37 = OpShiftRightLogical %v4uint %36 %28 + OpStore %x %37 + %40 = OpLoad %v4uint %x + %43 = OpBitwiseAnd %v4uint %40 %42 + %39 = OpINotEqual %v4bool %43 %27 + %38 = OpSelect %v4uint %39 %45 %27 + %46 = OpLoad %v4uint %x + %47 = OpShiftRightLogical %v4uint %46 %38 + OpStore %x %47 + %50 = OpLoad %v4uint %x + %53 = OpBitwiseAnd %v4uint %50 %52 + %49 = OpINotEqual %v4bool %53 %27 + %48 = OpSelect %v4uint %49 %55 %27 + %56 = OpLoad %v4uint %x + %57 = OpShiftRightLogical %v4uint %56 %48 + OpStore %x %57 + %60 = OpLoad %v4uint %x + %63 = OpBitwiseAnd %v4uint %60 %62 + %59 = OpINotEqual %v4bool %63 %27 + %58 = OpSelect %v4uint %59 %65 %27 + %66 = OpLoad %v4uint %x + %67 = OpShiftRightLogical %v4uint %66 %58 + OpStore %x %67 + %70 = OpLoad %v4uint %x + %71 = OpBitwiseAnd %v4uint %70 %65 + %69 = OpINotEqual %v4bool %71 %27 + %68 = OpSelect %v4uint %69 %73 %27 + %75 = OpLoad %v4uint %x + %76 = OpIEqual %v4bool %75 %27 + %74 = OpSelect %v4uint %76 %78 %27 + %80 = OpBitwiseOr %v4uint %28 %38 + %81 = OpBitwiseOr %v4uint %80 %48 + %82 = OpBitwiseOr %v4uint %81 %58 + %83 = OpBitwiseOr %v4uint %82 %68 + %84 = OpBitwiseOr %v4uint %83 %74 + %79 = OpBitcast %v4int %84 + OpReturnValue %79 OpFunctionEnd -%firstLeadingBit_c1f940 = OpFunction %void None %88 - %91 = OpLabel - %res = OpVariable %_ptr_Function_v4int Function %93 - %92 = OpFunctionCall %v4int %tint_first_leading_bit %93 - OpStore %res %92 +%firstLeadingBit_c1f940 = OpFunction %void None %85 + %88 = OpLabel + %res = OpVariable %_ptr_Function_v4int Function %18 + %89 = OpFunctionCall %v4int %tint_first_leading_bit %18 + OpStore %res %89 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %96 - %98 = OpLabel - %99 = OpFunctionCall %void %firstLeadingBit_c1f940 +%vertex_main_inner = OpFunction %v4float None %92 + %94 = OpLabel + %95 = OpFunctionCall %void %firstLeadingBit_c1f940 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %88 - %101 = OpLabel - %102 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %102 +%vertex_main = OpFunction %void None %85 + %97 = OpLabel + %98 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %98 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %88 - %105 = OpLabel - %106 = OpFunctionCall %void %firstLeadingBit_c1f940 +%fragment_main = OpFunction %void None %85 + %101 = OpLabel + %102 = OpFunctionCall %void %firstLeadingBit_c1f940 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %88 - %108 = OpLabel - %109 = OpFunctionCall %void %firstLeadingBit_c1f940 +%compute_main = OpFunction %void None %85 + %104 = OpLabel + %105 = OpFunctionCall %void %firstLeadingBit_c1f940 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/firstLeadingBit/f0779d.wgsl.expected.spvasm b/test/tint/builtins/gen/firstLeadingBit/f0779d.wgsl.expected.spvasm index 42c1b10c2a..c51a21b227 100644 --- a/test/tint/builtins/gen/firstLeadingBit/f0779d.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/firstLeadingBit/f0779d.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 86 +; Bound: 85 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -38,7 +38,6 @@ %bool = OpTypeBool %uint_4294901760 = OpConstant %uint 4294901760 %uint_16 = OpConstant %uint 16 - %uint_0 = OpConstant %uint 0 %uint_65280 = OpConstant %uint 65280 %uint_8 = OpConstant %uint 8 %uint_240 = OpConstant %uint 240 @@ -48,8 +47,8 @@ %uint_1 = OpConstant %uint 1 %uint_4294967295 = OpConstant %uint 4294967295 %void = OpTypeVoid - %66 = OpTypeFunction %void - %72 = OpTypeFunction %v4float + %65 = OpTypeFunction %void + %71 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_first_leading_bit = OpFunction %uint None %9 %v = OpFunctionParameter %uint @@ -59,71 +58,71 @@ %20 = OpLoad %uint %x %22 = OpBitwiseAnd %uint %20 %uint_4294901760 %18 = OpINotEqual %bool %22 %16 - %17 = OpSelect %uint %18 %uint_16 %uint_0 - %25 = OpLoad %uint %x - %26 = OpShiftRightLogical %uint %25 %17 - OpStore %x %26 - %29 = OpLoad %uint %x - %31 = OpBitwiseAnd %uint %29 %uint_65280 - %28 = OpINotEqual %bool %31 %16 - %27 = OpSelect %uint %28 %uint_8 %uint_0 - %33 = OpLoad %uint %x - %34 = OpShiftRightLogical %uint %33 %27 - OpStore %x %34 - %37 = OpLoad %uint %x - %39 = OpBitwiseAnd %uint %37 %uint_240 - %36 = OpINotEqual %bool %39 %16 - %35 = OpSelect %uint %36 %uint_4 %uint_0 - %41 = OpLoad %uint %x - %42 = OpShiftRightLogical %uint %41 %35 - OpStore %x %42 - %45 = OpLoad %uint %x - %47 = OpBitwiseAnd %uint %45 %uint_12 - %44 = OpINotEqual %bool %47 %16 - %43 = OpSelect %uint %44 %uint_2 %uint_0 - %49 = OpLoad %uint %x - %50 = OpShiftRightLogical %uint %49 %43 - OpStore %x %50 - %53 = OpLoad %uint %x - %54 = OpBitwiseAnd %uint %53 %uint_2 - %52 = OpINotEqual %bool %54 %16 - %51 = OpSelect %uint %52 %uint_1 %uint_0 - %57 = OpLoad %uint %x - %58 = OpIEqual %bool %57 %uint_0 - %56 = OpSelect %uint %58 %uint_4294967295 %uint_0 - %61 = OpBitwiseOr %uint %17 %27 - %62 = OpBitwiseOr %uint %61 %35 - %63 = OpBitwiseOr %uint %62 %43 - %64 = OpBitwiseOr %uint %63 %51 - %65 = OpBitwiseOr %uint %64 %56 - OpReturnValue %65 + %17 = OpSelect %uint %18 %uint_16 %16 + %24 = OpLoad %uint %x + %25 = OpShiftRightLogical %uint %24 %17 + OpStore %x %25 + %28 = OpLoad %uint %x + %30 = OpBitwiseAnd %uint %28 %uint_65280 + %27 = OpINotEqual %bool %30 %16 + %26 = OpSelect %uint %27 %uint_8 %16 + %32 = OpLoad %uint %x + %33 = OpShiftRightLogical %uint %32 %26 + OpStore %x %33 + %36 = OpLoad %uint %x + %38 = OpBitwiseAnd %uint %36 %uint_240 + %35 = OpINotEqual %bool %38 %16 + %34 = OpSelect %uint %35 %uint_4 %16 + %40 = OpLoad %uint %x + %41 = OpShiftRightLogical %uint %40 %34 + OpStore %x %41 + %44 = OpLoad %uint %x + %46 = OpBitwiseAnd %uint %44 %uint_12 + %43 = OpINotEqual %bool %46 %16 + %42 = OpSelect %uint %43 %uint_2 %16 + %48 = OpLoad %uint %x + %49 = OpShiftRightLogical %uint %48 %42 + OpStore %x %49 + %52 = OpLoad %uint %x + %53 = OpBitwiseAnd %uint %52 %uint_2 + %51 = OpINotEqual %bool %53 %16 + %50 = OpSelect %uint %51 %uint_1 %16 + %56 = OpLoad %uint %x + %57 = OpIEqual %bool %56 %16 + %55 = OpSelect %uint %57 %uint_4294967295 %16 + %60 = OpBitwiseOr %uint %17 %26 + %61 = OpBitwiseOr %uint %60 %34 + %62 = OpBitwiseOr %uint %61 %42 + %63 = OpBitwiseOr %uint %62 %50 + %64 = OpBitwiseOr %uint %63 %55 + OpReturnValue %64 OpFunctionEnd -%firstLeadingBit_f0779d = OpFunction %void None %66 - %69 = OpLabel +%firstLeadingBit_f0779d = OpFunction %void None %65 + %68 = OpLabel %res = OpVariable %_ptr_Function_uint Function %16 - %70 = OpFunctionCall %uint %tint_first_leading_bit %uint_1 - OpStore %res %70 + %69 = OpFunctionCall %uint %tint_first_leading_bit %uint_1 + OpStore %res %69 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %72 - %74 = OpLabel - %75 = OpFunctionCall %void %firstLeadingBit_f0779d +%vertex_main_inner = OpFunction %v4float None %71 + %73 = OpLabel + %74 = OpFunctionCall %void %firstLeadingBit_f0779d OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %66 - %77 = OpLabel - %78 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %78 +%vertex_main = OpFunction %void None %65 + %76 = OpLabel + %77 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %77 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %66 - %81 = OpLabel - %82 = OpFunctionCall %void %firstLeadingBit_f0779d +%fragment_main = OpFunction %void None %65 + %80 = OpLabel + %81 = OpFunctionCall %void %firstLeadingBit_f0779d OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %66 - %84 = OpLabel - %85 = OpFunctionCall %void %firstLeadingBit_f0779d +%compute_main = OpFunction %void None %65 + %83 = OpLabel + %84 = OpFunctionCall %void %firstLeadingBit_f0779d OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/firstTrailingBit/110f2c.wgsl.expected.spvasm b/test/tint/builtins/gen/firstTrailingBit/110f2c.wgsl.expected.spvasm index 7d9b599993..ddb3a41ab2 100644 --- a/test/tint/builtins/gen/firstTrailingBit/110f2c.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/firstTrailingBit/110f2c.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 100 +; Bound: 98 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -40,29 +40,27 @@ %v4bool = OpTypeVector %bool 4 %uint_65535 = OpConstant %uint 65535 %25 = OpConstantComposite %v4uint %uint_65535 %uint_65535 %uint_65535 %uint_65535 - %uint_0 = OpConstant %uint 0 - %28 = OpConstantComposite %v4uint %uint_0 %uint_0 %uint_0 %uint_0 %uint_16 = OpConstant %uint 16 - %30 = OpConstantComposite %v4uint %uint_16 %uint_16 %uint_16 %uint_16 + %28 = OpConstantComposite %v4uint %uint_16 %uint_16 %uint_16 %uint_16 %uint_255 = OpConstant %uint 255 - %37 = OpConstantComposite %v4uint %uint_255 %uint_255 %uint_255 %uint_255 + %35 = OpConstantComposite %v4uint %uint_255 %uint_255 %uint_255 %uint_255 %uint_8 = OpConstant %uint 8 - %40 = OpConstantComposite %v4uint %uint_8 %uint_8 %uint_8 %uint_8 + %38 = OpConstantComposite %v4uint %uint_8 %uint_8 %uint_8 %uint_8 %uint_15 = OpConstant %uint 15 - %47 = OpConstantComposite %v4uint %uint_15 %uint_15 %uint_15 %uint_15 + %45 = OpConstantComposite %v4uint %uint_15 %uint_15 %uint_15 %uint_15 %uint_4 = OpConstant %uint 4 - %50 = OpConstantComposite %v4uint %uint_4 %uint_4 %uint_4 %uint_4 + %48 = OpConstantComposite %v4uint %uint_4 %uint_4 %uint_4 %uint_4 %uint_3 = OpConstant %uint 3 - %57 = OpConstantComposite %v4uint %uint_3 %uint_3 %uint_3 %uint_3 + %55 = OpConstantComposite %v4uint %uint_3 %uint_3 %uint_3 %uint_3 %uint_2 = OpConstant %uint 2 - %60 = OpConstantComposite %v4uint %uint_2 %uint_2 %uint_2 %uint_2 + %58 = OpConstantComposite %v4uint %uint_2 %uint_2 %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %67 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 + %65 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 %uint_4294967295 = OpConstant %uint 4294967295 - %73 = OpConstantComposite %v4uint %uint_4294967295 %uint_4294967295 %uint_4294967295 %uint_4294967295 + %71 = OpConstantComposite %v4uint %uint_4294967295 %uint_4294967295 %uint_4294967295 %uint_4294967295 %void = OpTypeVoid - %80 = OpTypeFunction %void - %86 = OpTypeFunction %v4float + %78 = OpTypeFunction %void + %84 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_first_trailing_bit = OpFunction %v4uint None %9 %v = OpFunctionParameter %v4uint @@ -72,71 +70,71 @@ %23 = OpLoad %v4uint %x %26 = OpBitwiseAnd %v4uint %23 %25 %20 = OpINotEqual %v4bool %26 %18 - %19 = OpSelect %v4uint %20 %28 %30 - %31 = OpLoad %v4uint %x - %32 = OpShiftRightLogical %v4uint %31 %19 - OpStore %x %32 - %35 = OpLoad %v4uint %x - %38 = OpBitwiseAnd %v4uint %35 %37 - %34 = OpINotEqual %v4bool %38 %18 - %33 = OpSelect %v4uint %34 %28 %40 - %41 = OpLoad %v4uint %x - %42 = OpShiftRightLogical %v4uint %41 %33 - OpStore %x %42 - %45 = OpLoad %v4uint %x - %48 = OpBitwiseAnd %v4uint %45 %47 - %44 = OpINotEqual %v4bool %48 %18 - %43 = OpSelect %v4uint %44 %28 %50 - %51 = OpLoad %v4uint %x - %52 = OpShiftRightLogical %v4uint %51 %43 - OpStore %x %52 - %55 = OpLoad %v4uint %x - %58 = OpBitwiseAnd %v4uint %55 %57 - %54 = OpINotEqual %v4bool %58 %18 - %53 = OpSelect %v4uint %54 %28 %60 - %61 = OpLoad %v4uint %x - %62 = OpShiftRightLogical %v4uint %61 %53 - OpStore %x %62 - %65 = OpLoad %v4uint %x - %68 = OpBitwiseAnd %v4uint %65 %67 - %64 = OpINotEqual %v4bool %68 %18 - %63 = OpSelect %v4uint %64 %28 %67 - %70 = OpLoad %v4uint %x - %71 = OpIEqual %v4bool %70 %28 - %69 = OpSelect %v4uint %71 %73 %28 - %75 = OpBitwiseOr %v4uint %19 %33 - %76 = OpBitwiseOr %v4uint %75 %43 - %77 = OpBitwiseOr %v4uint %76 %53 - %78 = OpBitwiseOr %v4uint %77 %63 - %79 = OpBitwiseOr %v4uint %78 %69 - OpReturnValue %79 + %19 = OpSelect %v4uint %20 %18 %28 + %29 = OpLoad %v4uint %x + %30 = OpShiftRightLogical %v4uint %29 %19 + OpStore %x %30 + %33 = OpLoad %v4uint %x + %36 = OpBitwiseAnd %v4uint %33 %35 + %32 = OpINotEqual %v4bool %36 %18 + %31 = OpSelect %v4uint %32 %18 %38 + %39 = OpLoad %v4uint %x + %40 = OpShiftRightLogical %v4uint %39 %31 + OpStore %x %40 + %43 = OpLoad %v4uint %x + %46 = OpBitwiseAnd %v4uint %43 %45 + %42 = OpINotEqual %v4bool %46 %18 + %41 = OpSelect %v4uint %42 %18 %48 + %49 = OpLoad %v4uint %x + %50 = OpShiftRightLogical %v4uint %49 %41 + OpStore %x %50 + %53 = OpLoad %v4uint %x + %56 = OpBitwiseAnd %v4uint %53 %55 + %52 = OpINotEqual %v4bool %56 %18 + %51 = OpSelect %v4uint %52 %18 %58 + %59 = OpLoad %v4uint %x + %60 = OpShiftRightLogical %v4uint %59 %51 + OpStore %x %60 + %63 = OpLoad %v4uint %x + %66 = OpBitwiseAnd %v4uint %63 %65 + %62 = OpINotEqual %v4bool %66 %18 + %61 = OpSelect %v4uint %62 %18 %65 + %68 = OpLoad %v4uint %x + %69 = OpIEqual %v4bool %68 %18 + %67 = OpSelect %v4uint %69 %71 %18 + %73 = OpBitwiseOr %v4uint %19 %31 + %74 = OpBitwiseOr %v4uint %73 %41 + %75 = OpBitwiseOr %v4uint %74 %51 + %76 = OpBitwiseOr %v4uint %75 %61 + %77 = OpBitwiseOr %v4uint %76 %67 + OpReturnValue %77 OpFunctionEnd -%firstTrailingBit_110f2c = OpFunction %void None %80 - %83 = OpLabel +%firstTrailingBit_110f2c = OpFunction %void None %78 + %81 = OpLabel %res = OpVariable %_ptr_Function_v4uint Function %18 - %84 = OpFunctionCall %v4uint %tint_first_trailing_bit %18 - OpStore %res %84 + %82 = OpFunctionCall %v4uint %tint_first_trailing_bit %18 + OpStore %res %82 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %86 - %88 = OpLabel - %89 = OpFunctionCall %void %firstTrailingBit_110f2c +%vertex_main_inner = OpFunction %v4float None %84 + %86 = OpLabel + %87 = OpFunctionCall %void %firstTrailingBit_110f2c OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %80 - %91 = OpLabel - %92 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %92 +%vertex_main = OpFunction %void None %78 + %89 = OpLabel + %90 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %90 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %80 - %95 = OpLabel - %96 = OpFunctionCall %void %firstTrailingBit_110f2c +%fragment_main = OpFunction %void None %78 + %93 = OpLabel + %94 = OpFunctionCall %void %firstTrailingBit_110f2c OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %80 - %98 = OpLabel - %99 = OpFunctionCall %void %firstTrailingBit_110f2c +%compute_main = OpFunction %void None %78 + %96 = OpLabel + %97 = OpFunctionCall %void %firstTrailingBit_110f2c OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/firstTrailingBit/3a2acc.wgsl.expected.spvasm b/test/tint/builtins/gen/firstTrailingBit/3a2acc.wgsl.expected.spvasm index 491f4a430d..353d5ddc11 100644 --- a/test/tint/builtins/gen/firstTrailingBit/3a2acc.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/firstTrailingBit/3a2acc.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 91 +; Bound: 90 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -38,7 +38,6 @@ %18 = OpConstantNull %uint %bool = OpTypeBool %uint_65535 = OpConstant %uint 65535 - %uint_0 = OpConstant %uint 0 %uint_16 = OpConstant %uint 16 %uint_255 = OpConstant %uint 255 %uint_8 = OpConstant %uint 8 @@ -49,11 +48,11 @@ %uint_1 = OpConstant %uint 1 %uint_4294967295 = OpConstant %uint 4294967295 %void = OpTypeVoid - %68 = OpTypeFunction %void + %67 = OpTypeFunction %void %int_1 = OpConstant %int 1 %_ptr_Function_int = OpTypePointer Function %int - %76 = OpConstantNull %int - %77 = OpTypeFunction %v4float + %75 = OpConstantNull %int + %76 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_first_trailing_bit = OpFunction %int None %9 %v = OpFunctionParameter %int @@ -64,72 +63,72 @@ %22 = OpLoad %uint %x %24 = OpBitwiseAnd %uint %22 %uint_65535 %20 = OpINotEqual %bool %24 %18 - %19 = OpSelect %uint %20 %uint_0 %uint_16 - %27 = OpLoad %uint %x - %28 = OpShiftRightLogical %uint %27 %19 - OpStore %x %28 - %31 = OpLoad %uint %x - %33 = OpBitwiseAnd %uint %31 %uint_255 - %30 = OpINotEqual %bool %33 %18 - %29 = OpSelect %uint %30 %uint_0 %uint_8 - %35 = OpLoad %uint %x - %36 = OpShiftRightLogical %uint %35 %29 - OpStore %x %36 - %39 = OpLoad %uint %x - %41 = OpBitwiseAnd %uint %39 %uint_15 - %38 = OpINotEqual %bool %41 %18 - %37 = OpSelect %uint %38 %uint_0 %uint_4 - %43 = OpLoad %uint %x - %44 = OpShiftRightLogical %uint %43 %37 - OpStore %x %44 - %47 = OpLoad %uint %x - %49 = OpBitwiseAnd %uint %47 %uint_3 - %46 = OpINotEqual %bool %49 %18 - %45 = OpSelect %uint %46 %uint_0 %uint_2 - %51 = OpLoad %uint %x - %52 = OpShiftRightLogical %uint %51 %45 - OpStore %x %52 - %55 = OpLoad %uint %x - %57 = OpBitwiseAnd %uint %55 %uint_1 - %54 = OpINotEqual %bool %57 %18 - %53 = OpSelect %uint %54 %uint_0 %uint_1 - %59 = OpLoad %uint %x - %60 = OpIEqual %bool %59 %uint_0 - %58 = OpSelect %uint %60 %uint_4294967295 %uint_0 - %63 = OpBitwiseOr %uint %19 %29 - %64 = OpBitwiseOr %uint %63 %37 - %65 = OpBitwiseOr %uint %64 %45 - %66 = OpBitwiseOr %uint %65 %53 - %67 = OpBitwiseOr %uint %66 %58 - %62 = OpBitcast %int %67 - OpReturnValue %62 + %19 = OpSelect %uint %20 %18 %uint_16 + %26 = OpLoad %uint %x + %27 = OpShiftRightLogical %uint %26 %19 + OpStore %x %27 + %30 = OpLoad %uint %x + %32 = OpBitwiseAnd %uint %30 %uint_255 + %29 = OpINotEqual %bool %32 %18 + %28 = OpSelect %uint %29 %18 %uint_8 + %34 = OpLoad %uint %x + %35 = OpShiftRightLogical %uint %34 %28 + OpStore %x %35 + %38 = OpLoad %uint %x + %40 = OpBitwiseAnd %uint %38 %uint_15 + %37 = OpINotEqual %bool %40 %18 + %36 = OpSelect %uint %37 %18 %uint_4 + %42 = OpLoad %uint %x + %43 = OpShiftRightLogical %uint %42 %36 + OpStore %x %43 + %46 = OpLoad %uint %x + %48 = OpBitwiseAnd %uint %46 %uint_3 + %45 = OpINotEqual %bool %48 %18 + %44 = OpSelect %uint %45 %18 %uint_2 + %50 = OpLoad %uint %x + %51 = OpShiftRightLogical %uint %50 %44 + OpStore %x %51 + %54 = OpLoad %uint %x + %56 = OpBitwiseAnd %uint %54 %uint_1 + %53 = OpINotEqual %bool %56 %18 + %52 = OpSelect %uint %53 %18 %uint_1 + %58 = OpLoad %uint %x + %59 = OpIEqual %bool %58 %18 + %57 = OpSelect %uint %59 %uint_4294967295 %18 + %62 = OpBitwiseOr %uint %19 %28 + %63 = OpBitwiseOr %uint %62 %36 + %64 = OpBitwiseOr %uint %63 %44 + %65 = OpBitwiseOr %uint %64 %52 + %66 = OpBitwiseOr %uint %65 %57 + %61 = OpBitcast %int %66 + OpReturnValue %61 OpFunctionEnd -%firstTrailingBit_3a2acc = OpFunction %void None %68 - %71 = OpLabel - %res = OpVariable %_ptr_Function_int Function %76 - %72 = OpFunctionCall %int %tint_first_trailing_bit %int_1 - OpStore %res %72 +%firstTrailingBit_3a2acc = OpFunction %void None %67 + %70 = OpLabel + %res = OpVariable %_ptr_Function_int Function %75 + %71 = OpFunctionCall %int %tint_first_trailing_bit %int_1 + OpStore %res %71 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %77 - %79 = OpLabel - %80 = OpFunctionCall %void %firstTrailingBit_3a2acc +%vertex_main_inner = OpFunction %v4float None %76 + %78 = OpLabel + %79 = OpFunctionCall %void %firstTrailingBit_3a2acc OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %68 - %82 = OpLabel - %83 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %83 +%vertex_main = OpFunction %void None %67 + %81 = OpLabel + %82 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %82 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %68 - %86 = OpLabel - %87 = OpFunctionCall %void %firstTrailingBit_3a2acc +%fragment_main = OpFunction %void None %67 + %85 = OpLabel + %86 = OpFunctionCall %void %firstTrailingBit_3a2acc OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %68 - %89 = OpLabel - %90 = OpFunctionCall %void %firstTrailingBit_3a2acc +%compute_main = OpFunction %void None %67 + %88 = OpLabel + %89 = OpFunctionCall %void %firstTrailingBit_3a2acc OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/firstTrailingBit/45eb10.wgsl.expected.spvasm b/test/tint/builtins/gen/firstTrailingBit/45eb10.wgsl.expected.spvasm index ca8428cfc2..7bb312a61c 100644 --- a/test/tint/builtins/gen/firstTrailingBit/45eb10.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/firstTrailingBit/45eb10.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 100 +; Bound: 98 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -40,29 +40,27 @@ %v2bool = OpTypeVector %bool 2 %uint_65535 = OpConstant %uint 65535 %25 = OpConstantComposite %v2uint %uint_65535 %uint_65535 - %uint_0 = OpConstant %uint 0 - %28 = OpConstantComposite %v2uint %uint_0 %uint_0 %uint_16 = OpConstant %uint 16 - %30 = OpConstantComposite %v2uint %uint_16 %uint_16 + %28 = OpConstantComposite %v2uint %uint_16 %uint_16 %uint_255 = OpConstant %uint 255 - %37 = OpConstantComposite %v2uint %uint_255 %uint_255 + %35 = OpConstantComposite %v2uint %uint_255 %uint_255 %uint_8 = OpConstant %uint 8 - %40 = OpConstantComposite %v2uint %uint_8 %uint_8 + %38 = OpConstantComposite %v2uint %uint_8 %uint_8 %uint_15 = OpConstant %uint 15 - %47 = OpConstantComposite %v2uint %uint_15 %uint_15 + %45 = OpConstantComposite %v2uint %uint_15 %uint_15 %uint_4 = OpConstant %uint 4 - %50 = OpConstantComposite %v2uint %uint_4 %uint_4 + %48 = OpConstantComposite %v2uint %uint_4 %uint_4 %uint_3 = OpConstant %uint 3 - %57 = OpConstantComposite %v2uint %uint_3 %uint_3 + %55 = OpConstantComposite %v2uint %uint_3 %uint_3 %uint_2 = OpConstant %uint 2 - %60 = OpConstantComposite %v2uint %uint_2 %uint_2 + %58 = OpConstantComposite %v2uint %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %67 = OpConstantComposite %v2uint %uint_1 %uint_1 + %65 = OpConstantComposite %v2uint %uint_1 %uint_1 %uint_4294967295 = OpConstant %uint 4294967295 - %73 = OpConstantComposite %v2uint %uint_4294967295 %uint_4294967295 + %71 = OpConstantComposite %v2uint %uint_4294967295 %uint_4294967295 %void = OpTypeVoid - %80 = OpTypeFunction %void - %86 = OpTypeFunction %v4float + %78 = OpTypeFunction %void + %84 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_first_trailing_bit = OpFunction %v2uint None %9 %v = OpFunctionParameter %v2uint @@ -72,71 +70,71 @@ %23 = OpLoad %v2uint %x %26 = OpBitwiseAnd %v2uint %23 %25 %20 = OpINotEqual %v2bool %26 %18 - %19 = OpSelect %v2uint %20 %28 %30 - %31 = OpLoad %v2uint %x - %32 = OpShiftRightLogical %v2uint %31 %19 - OpStore %x %32 - %35 = OpLoad %v2uint %x - %38 = OpBitwiseAnd %v2uint %35 %37 - %34 = OpINotEqual %v2bool %38 %18 - %33 = OpSelect %v2uint %34 %28 %40 - %41 = OpLoad %v2uint %x - %42 = OpShiftRightLogical %v2uint %41 %33 - OpStore %x %42 - %45 = OpLoad %v2uint %x - %48 = OpBitwiseAnd %v2uint %45 %47 - %44 = OpINotEqual %v2bool %48 %18 - %43 = OpSelect %v2uint %44 %28 %50 - %51 = OpLoad %v2uint %x - %52 = OpShiftRightLogical %v2uint %51 %43 - OpStore %x %52 - %55 = OpLoad %v2uint %x - %58 = OpBitwiseAnd %v2uint %55 %57 - %54 = OpINotEqual %v2bool %58 %18 - %53 = OpSelect %v2uint %54 %28 %60 - %61 = OpLoad %v2uint %x - %62 = OpShiftRightLogical %v2uint %61 %53 - OpStore %x %62 - %65 = OpLoad %v2uint %x - %68 = OpBitwiseAnd %v2uint %65 %67 - %64 = OpINotEqual %v2bool %68 %18 - %63 = OpSelect %v2uint %64 %28 %67 - %70 = OpLoad %v2uint %x - %71 = OpIEqual %v2bool %70 %28 - %69 = OpSelect %v2uint %71 %73 %28 - %75 = OpBitwiseOr %v2uint %19 %33 - %76 = OpBitwiseOr %v2uint %75 %43 - %77 = OpBitwiseOr %v2uint %76 %53 - %78 = OpBitwiseOr %v2uint %77 %63 - %79 = OpBitwiseOr %v2uint %78 %69 - OpReturnValue %79 + %19 = OpSelect %v2uint %20 %18 %28 + %29 = OpLoad %v2uint %x + %30 = OpShiftRightLogical %v2uint %29 %19 + OpStore %x %30 + %33 = OpLoad %v2uint %x + %36 = OpBitwiseAnd %v2uint %33 %35 + %32 = OpINotEqual %v2bool %36 %18 + %31 = OpSelect %v2uint %32 %18 %38 + %39 = OpLoad %v2uint %x + %40 = OpShiftRightLogical %v2uint %39 %31 + OpStore %x %40 + %43 = OpLoad %v2uint %x + %46 = OpBitwiseAnd %v2uint %43 %45 + %42 = OpINotEqual %v2bool %46 %18 + %41 = OpSelect %v2uint %42 %18 %48 + %49 = OpLoad %v2uint %x + %50 = OpShiftRightLogical %v2uint %49 %41 + OpStore %x %50 + %53 = OpLoad %v2uint %x + %56 = OpBitwiseAnd %v2uint %53 %55 + %52 = OpINotEqual %v2bool %56 %18 + %51 = OpSelect %v2uint %52 %18 %58 + %59 = OpLoad %v2uint %x + %60 = OpShiftRightLogical %v2uint %59 %51 + OpStore %x %60 + %63 = OpLoad %v2uint %x + %66 = OpBitwiseAnd %v2uint %63 %65 + %62 = OpINotEqual %v2bool %66 %18 + %61 = OpSelect %v2uint %62 %18 %65 + %68 = OpLoad %v2uint %x + %69 = OpIEqual %v2bool %68 %18 + %67 = OpSelect %v2uint %69 %71 %18 + %73 = OpBitwiseOr %v2uint %19 %31 + %74 = OpBitwiseOr %v2uint %73 %41 + %75 = OpBitwiseOr %v2uint %74 %51 + %76 = OpBitwiseOr %v2uint %75 %61 + %77 = OpBitwiseOr %v2uint %76 %67 + OpReturnValue %77 OpFunctionEnd -%firstTrailingBit_45eb10 = OpFunction %void None %80 - %83 = OpLabel +%firstTrailingBit_45eb10 = OpFunction %void None %78 + %81 = OpLabel %res = OpVariable %_ptr_Function_v2uint Function %18 - %84 = OpFunctionCall %v2uint %tint_first_trailing_bit %18 - OpStore %res %84 + %82 = OpFunctionCall %v2uint %tint_first_trailing_bit %18 + OpStore %res %82 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %86 - %88 = OpLabel - %89 = OpFunctionCall %void %firstTrailingBit_45eb10 +%vertex_main_inner = OpFunction %v4float None %84 + %86 = OpLabel + %87 = OpFunctionCall %void %firstTrailingBit_45eb10 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %80 - %91 = OpLabel - %92 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %92 +%vertex_main = OpFunction %void None %78 + %89 = OpLabel + %90 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %90 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %80 - %95 = OpLabel - %96 = OpFunctionCall %void %firstTrailingBit_45eb10 +%fragment_main = OpFunction %void None %78 + %93 = OpLabel + %94 = OpFunctionCall %void %firstTrailingBit_45eb10 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %80 - %98 = OpLabel - %99 = OpFunctionCall %void %firstTrailingBit_45eb10 +%compute_main = OpFunction %void None %78 + %96 = OpLabel + %97 = OpFunctionCall %void %firstTrailingBit_45eb10 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/firstTrailingBit/47d475.wgsl.expected.spvasm b/test/tint/builtins/gen/firstTrailingBit/47d475.wgsl.expected.spvasm index 2c9f7a3b58..7f60ef1b61 100644 --- a/test/tint/builtins/gen/firstTrailingBit/47d475.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/firstTrailingBit/47d475.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 87 +; Bound: 86 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -37,7 +37,6 @@ %17 = OpConstantNull %uint %bool = OpTypeBool %uint_65535 = OpConstant %uint 65535 - %uint_0 = OpConstant %uint 0 %uint_16 = OpConstant %uint 16 %uint_255 = OpConstant %uint 255 %uint_8 = OpConstant %uint 8 @@ -48,8 +47,8 @@ %uint_1 = OpConstant %uint 1 %uint_4294967295 = OpConstant %uint 4294967295 %void = OpTypeVoid - %67 = OpTypeFunction %void - %73 = OpTypeFunction %v4float + %66 = OpTypeFunction %void + %72 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_first_trailing_bit = OpFunction %uint None %9 %v = OpFunctionParameter %uint @@ -59,71 +58,71 @@ %21 = OpLoad %uint %x %23 = OpBitwiseAnd %uint %21 %uint_65535 %19 = OpINotEqual %bool %23 %17 - %18 = OpSelect %uint %19 %uint_0 %uint_16 - %26 = OpLoad %uint %x - %27 = OpShiftRightLogical %uint %26 %18 - OpStore %x %27 - %30 = OpLoad %uint %x - %32 = OpBitwiseAnd %uint %30 %uint_255 - %29 = OpINotEqual %bool %32 %17 - %28 = OpSelect %uint %29 %uint_0 %uint_8 - %34 = OpLoad %uint %x - %35 = OpShiftRightLogical %uint %34 %28 - OpStore %x %35 - %38 = OpLoad %uint %x - %40 = OpBitwiseAnd %uint %38 %uint_15 - %37 = OpINotEqual %bool %40 %17 - %36 = OpSelect %uint %37 %uint_0 %uint_4 - %42 = OpLoad %uint %x - %43 = OpShiftRightLogical %uint %42 %36 - OpStore %x %43 - %46 = OpLoad %uint %x - %48 = OpBitwiseAnd %uint %46 %uint_3 - %45 = OpINotEqual %bool %48 %17 - %44 = OpSelect %uint %45 %uint_0 %uint_2 - %50 = OpLoad %uint %x - %51 = OpShiftRightLogical %uint %50 %44 - OpStore %x %51 - %54 = OpLoad %uint %x - %56 = OpBitwiseAnd %uint %54 %uint_1 - %53 = OpINotEqual %bool %56 %17 - %52 = OpSelect %uint %53 %uint_0 %uint_1 - %58 = OpLoad %uint %x - %59 = OpIEqual %bool %58 %uint_0 - %57 = OpSelect %uint %59 %uint_4294967295 %uint_0 - %62 = OpBitwiseOr %uint %18 %28 - %63 = OpBitwiseOr %uint %62 %36 - %64 = OpBitwiseOr %uint %63 %44 - %65 = OpBitwiseOr %uint %64 %52 - %66 = OpBitwiseOr %uint %65 %57 - OpReturnValue %66 + %18 = OpSelect %uint %19 %17 %uint_16 + %25 = OpLoad %uint %x + %26 = OpShiftRightLogical %uint %25 %18 + OpStore %x %26 + %29 = OpLoad %uint %x + %31 = OpBitwiseAnd %uint %29 %uint_255 + %28 = OpINotEqual %bool %31 %17 + %27 = OpSelect %uint %28 %17 %uint_8 + %33 = OpLoad %uint %x + %34 = OpShiftRightLogical %uint %33 %27 + OpStore %x %34 + %37 = OpLoad %uint %x + %39 = OpBitwiseAnd %uint %37 %uint_15 + %36 = OpINotEqual %bool %39 %17 + %35 = OpSelect %uint %36 %17 %uint_4 + %41 = OpLoad %uint %x + %42 = OpShiftRightLogical %uint %41 %35 + OpStore %x %42 + %45 = OpLoad %uint %x + %47 = OpBitwiseAnd %uint %45 %uint_3 + %44 = OpINotEqual %bool %47 %17 + %43 = OpSelect %uint %44 %17 %uint_2 + %49 = OpLoad %uint %x + %50 = OpShiftRightLogical %uint %49 %43 + OpStore %x %50 + %53 = OpLoad %uint %x + %55 = OpBitwiseAnd %uint %53 %uint_1 + %52 = OpINotEqual %bool %55 %17 + %51 = OpSelect %uint %52 %17 %uint_1 + %57 = OpLoad %uint %x + %58 = OpIEqual %bool %57 %17 + %56 = OpSelect %uint %58 %uint_4294967295 %17 + %61 = OpBitwiseOr %uint %18 %27 + %62 = OpBitwiseOr %uint %61 %35 + %63 = OpBitwiseOr %uint %62 %43 + %64 = OpBitwiseOr %uint %63 %51 + %65 = OpBitwiseOr %uint %64 %56 + OpReturnValue %65 OpFunctionEnd -%firstTrailingBit_47d475 = OpFunction %void None %67 - %70 = OpLabel +%firstTrailingBit_47d475 = OpFunction %void None %66 + %69 = OpLabel %res = OpVariable %_ptr_Function_uint Function %17 - %71 = OpFunctionCall %uint %tint_first_trailing_bit %uint_1 - OpStore %res %71 + %70 = OpFunctionCall %uint %tint_first_trailing_bit %uint_1 + OpStore %res %70 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %73 - %75 = OpLabel - %76 = OpFunctionCall %void %firstTrailingBit_47d475 +%vertex_main_inner = OpFunction %v4float None %72 + %74 = OpLabel + %75 = OpFunctionCall %void %firstTrailingBit_47d475 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %67 - %78 = OpLabel - %79 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %79 +%vertex_main = OpFunction %void None %66 + %77 = OpLabel + %78 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %78 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %67 - %82 = OpLabel - %83 = OpFunctionCall %void %firstTrailingBit_47d475 +%fragment_main = OpFunction %void None %66 + %81 = OpLabel + %82 = OpFunctionCall %void %firstTrailingBit_47d475 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %67 - %85 = OpLabel - %86 = OpFunctionCall %void %firstTrailingBit_47d475 +%compute_main = OpFunction %void None %66 + %84 = OpLabel + %85 = OpFunctionCall %void %firstTrailingBit_47d475 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/firstTrailingBit/50c072.wgsl.expected.spvasm b/test/tint/builtins/gen/firstTrailingBit/50c072.wgsl.expected.spvasm index 8b5d1d84e2..d2ea1952b8 100644 --- a/test/tint/builtins/gen/firstTrailingBit/50c072.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/firstTrailingBit/50c072.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 104 +; Bound: 102 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -42,31 +42,29 @@ %v2bool = OpTypeVector %bool 2 %uint_65535 = OpConstant %uint 65535 %27 = OpConstantComposite %v2uint %uint_65535 %uint_65535 - %uint_0 = OpConstant %uint 0 - %30 = OpConstantComposite %v2uint %uint_0 %uint_0 %uint_16 = OpConstant %uint 16 - %32 = OpConstantComposite %v2uint %uint_16 %uint_16 + %30 = OpConstantComposite %v2uint %uint_16 %uint_16 %uint_255 = OpConstant %uint 255 - %39 = OpConstantComposite %v2uint %uint_255 %uint_255 + %37 = OpConstantComposite %v2uint %uint_255 %uint_255 %uint_8 = OpConstant %uint 8 - %42 = OpConstantComposite %v2uint %uint_8 %uint_8 + %40 = OpConstantComposite %v2uint %uint_8 %uint_8 %uint_15 = OpConstant %uint 15 - %49 = OpConstantComposite %v2uint %uint_15 %uint_15 + %47 = OpConstantComposite %v2uint %uint_15 %uint_15 %uint_4 = OpConstant %uint 4 - %52 = OpConstantComposite %v2uint %uint_4 %uint_4 + %50 = OpConstantComposite %v2uint %uint_4 %uint_4 %uint_3 = OpConstant %uint 3 - %59 = OpConstantComposite %v2uint %uint_3 %uint_3 + %57 = OpConstantComposite %v2uint %uint_3 %uint_3 %uint_2 = OpConstant %uint 2 - %62 = OpConstantComposite %v2uint %uint_2 %uint_2 + %60 = OpConstantComposite %v2uint %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %69 = OpConstantComposite %v2uint %uint_1 %uint_1 + %67 = OpConstantComposite %v2uint %uint_1 %uint_1 %uint_4294967295 = OpConstant %uint 4294967295 - %75 = OpConstantComposite %v2uint %uint_4294967295 %uint_4294967295 + %73 = OpConstantComposite %v2uint %uint_4294967295 %uint_4294967295 %void = OpTypeVoid - %82 = OpTypeFunction %void - %87 = OpConstantNull %v2int + %80 = OpTypeFunction %void + %85 = OpConstantNull %v2int %_ptr_Function_v2int = OpTypePointer Function %v2int - %90 = OpTypeFunction %v4float + %88 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_first_trailing_bit = OpFunction %v2int None %9 %v = OpFunctionParameter %v2int @@ -77,72 +75,72 @@ %25 = OpLoad %v2uint %x %28 = OpBitwiseAnd %v2uint %25 %27 %22 = OpINotEqual %v2bool %28 %20 - %21 = OpSelect %v2uint %22 %30 %32 - %33 = OpLoad %v2uint %x - %34 = OpShiftRightLogical %v2uint %33 %21 - OpStore %x %34 - %37 = OpLoad %v2uint %x - %40 = OpBitwiseAnd %v2uint %37 %39 - %36 = OpINotEqual %v2bool %40 %20 - %35 = OpSelect %v2uint %36 %30 %42 - %43 = OpLoad %v2uint %x - %44 = OpShiftRightLogical %v2uint %43 %35 - OpStore %x %44 - %47 = OpLoad %v2uint %x - %50 = OpBitwiseAnd %v2uint %47 %49 - %46 = OpINotEqual %v2bool %50 %20 - %45 = OpSelect %v2uint %46 %30 %52 - %53 = OpLoad %v2uint %x - %54 = OpShiftRightLogical %v2uint %53 %45 - OpStore %x %54 - %57 = OpLoad %v2uint %x - %60 = OpBitwiseAnd %v2uint %57 %59 - %56 = OpINotEqual %v2bool %60 %20 - %55 = OpSelect %v2uint %56 %30 %62 - %63 = OpLoad %v2uint %x - %64 = OpShiftRightLogical %v2uint %63 %55 - OpStore %x %64 - %67 = OpLoad %v2uint %x - %70 = OpBitwiseAnd %v2uint %67 %69 - %66 = OpINotEqual %v2bool %70 %20 - %65 = OpSelect %v2uint %66 %30 %69 - %72 = OpLoad %v2uint %x - %73 = OpIEqual %v2bool %72 %30 - %71 = OpSelect %v2uint %73 %75 %30 - %77 = OpBitwiseOr %v2uint %21 %35 - %78 = OpBitwiseOr %v2uint %77 %45 - %79 = OpBitwiseOr %v2uint %78 %55 - %80 = OpBitwiseOr %v2uint %79 %65 - %81 = OpBitwiseOr %v2uint %80 %71 - %76 = OpBitcast %v2int %81 - OpReturnValue %76 + %21 = OpSelect %v2uint %22 %20 %30 + %31 = OpLoad %v2uint %x + %32 = OpShiftRightLogical %v2uint %31 %21 + OpStore %x %32 + %35 = OpLoad %v2uint %x + %38 = OpBitwiseAnd %v2uint %35 %37 + %34 = OpINotEqual %v2bool %38 %20 + %33 = OpSelect %v2uint %34 %20 %40 + %41 = OpLoad %v2uint %x + %42 = OpShiftRightLogical %v2uint %41 %33 + OpStore %x %42 + %45 = OpLoad %v2uint %x + %48 = OpBitwiseAnd %v2uint %45 %47 + %44 = OpINotEqual %v2bool %48 %20 + %43 = OpSelect %v2uint %44 %20 %50 + %51 = OpLoad %v2uint %x + %52 = OpShiftRightLogical %v2uint %51 %43 + OpStore %x %52 + %55 = OpLoad %v2uint %x + %58 = OpBitwiseAnd %v2uint %55 %57 + %54 = OpINotEqual %v2bool %58 %20 + %53 = OpSelect %v2uint %54 %20 %60 + %61 = OpLoad %v2uint %x + %62 = OpShiftRightLogical %v2uint %61 %53 + OpStore %x %62 + %65 = OpLoad %v2uint %x + %68 = OpBitwiseAnd %v2uint %65 %67 + %64 = OpINotEqual %v2bool %68 %20 + %63 = OpSelect %v2uint %64 %20 %67 + %70 = OpLoad %v2uint %x + %71 = OpIEqual %v2bool %70 %20 + %69 = OpSelect %v2uint %71 %73 %20 + %75 = OpBitwiseOr %v2uint %21 %33 + %76 = OpBitwiseOr %v2uint %75 %43 + %77 = OpBitwiseOr %v2uint %76 %53 + %78 = OpBitwiseOr %v2uint %77 %63 + %79 = OpBitwiseOr %v2uint %78 %69 + %74 = OpBitcast %v2int %79 + OpReturnValue %74 OpFunctionEnd -%firstTrailingBit_50c072 = OpFunction %void None %82 - %85 = OpLabel - %res = OpVariable %_ptr_Function_v2int Function %87 - %86 = OpFunctionCall %v2int %tint_first_trailing_bit %87 - OpStore %res %86 +%firstTrailingBit_50c072 = OpFunction %void None %80 + %83 = OpLabel + %res = OpVariable %_ptr_Function_v2int Function %85 + %84 = OpFunctionCall %v2int %tint_first_trailing_bit %85 + OpStore %res %84 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %90 - %92 = OpLabel - %93 = OpFunctionCall %void %firstTrailingBit_50c072 +%vertex_main_inner = OpFunction %v4float None %88 + %90 = OpLabel + %91 = OpFunctionCall %void %firstTrailingBit_50c072 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %82 - %95 = OpLabel - %96 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %96 +%vertex_main = OpFunction %void None %80 + %93 = OpLabel + %94 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %94 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %82 - %99 = OpLabel - %100 = OpFunctionCall %void %firstTrailingBit_50c072 +%fragment_main = OpFunction %void None %80 + %97 = OpLabel + %98 = OpFunctionCall %void %firstTrailingBit_50c072 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %82 - %102 = OpLabel - %103 = OpFunctionCall %void %firstTrailingBit_50c072 +%compute_main = OpFunction %void None %80 + %100 = OpLabel + %101 = OpFunctionCall %void %firstTrailingBit_50c072 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/firstTrailingBit/7496d6.wgsl.expected.spvasm b/test/tint/builtins/gen/firstTrailingBit/7496d6.wgsl.expected.spvasm index edbc24ca60..a0178624c7 100644 --- a/test/tint/builtins/gen/firstTrailingBit/7496d6.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/firstTrailingBit/7496d6.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 104 +; Bound: 102 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -42,31 +42,29 @@ %v3bool = OpTypeVector %bool 3 %uint_65535 = OpConstant %uint 65535 %27 = OpConstantComposite %v3uint %uint_65535 %uint_65535 %uint_65535 - %uint_0 = OpConstant %uint 0 - %30 = OpConstantComposite %v3uint %uint_0 %uint_0 %uint_0 %uint_16 = OpConstant %uint 16 - %32 = OpConstantComposite %v3uint %uint_16 %uint_16 %uint_16 + %30 = OpConstantComposite %v3uint %uint_16 %uint_16 %uint_16 %uint_255 = OpConstant %uint 255 - %39 = OpConstantComposite %v3uint %uint_255 %uint_255 %uint_255 + %37 = OpConstantComposite %v3uint %uint_255 %uint_255 %uint_255 %uint_8 = OpConstant %uint 8 - %42 = OpConstantComposite %v3uint %uint_8 %uint_8 %uint_8 + %40 = OpConstantComposite %v3uint %uint_8 %uint_8 %uint_8 %uint_15 = OpConstant %uint 15 - %49 = OpConstantComposite %v3uint %uint_15 %uint_15 %uint_15 + %47 = OpConstantComposite %v3uint %uint_15 %uint_15 %uint_15 %uint_4 = OpConstant %uint 4 - %52 = OpConstantComposite %v3uint %uint_4 %uint_4 %uint_4 + %50 = OpConstantComposite %v3uint %uint_4 %uint_4 %uint_4 %uint_3 = OpConstant %uint 3 - %59 = OpConstantComposite %v3uint %uint_3 %uint_3 %uint_3 + %57 = OpConstantComposite %v3uint %uint_3 %uint_3 %uint_3 %uint_2 = OpConstant %uint 2 - %62 = OpConstantComposite %v3uint %uint_2 %uint_2 %uint_2 + %60 = OpConstantComposite %v3uint %uint_2 %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %69 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 + %67 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %uint_4294967295 = OpConstant %uint 4294967295 - %75 = OpConstantComposite %v3uint %uint_4294967295 %uint_4294967295 %uint_4294967295 + %73 = OpConstantComposite %v3uint %uint_4294967295 %uint_4294967295 %uint_4294967295 %void = OpTypeVoid - %82 = OpTypeFunction %void - %87 = OpConstantNull %v3int + %80 = OpTypeFunction %void + %85 = OpConstantNull %v3int %_ptr_Function_v3int = OpTypePointer Function %v3int - %90 = OpTypeFunction %v4float + %88 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_first_trailing_bit = OpFunction %v3int None %9 %v = OpFunctionParameter %v3int @@ -77,72 +75,72 @@ %25 = OpLoad %v3uint %x %28 = OpBitwiseAnd %v3uint %25 %27 %22 = OpINotEqual %v3bool %28 %20 - %21 = OpSelect %v3uint %22 %30 %32 - %33 = OpLoad %v3uint %x - %34 = OpShiftRightLogical %v3uint %33 %21 - OpStore %x %34 - %37 = OpLoad %v3uint %x - %40 = OpBitwiseAnd %v3uint %37 %39 - %36 = OpINotEqual %v3bool %40 %20 - %35 = OpSelect %v3uint %36 %30 %42 - %43 = OpLoad %v3uint %x - %44 = OpShiftRightLogical %v3uint %43 %35 - OpStore %x %44 - %47 = OpLoad %v3uint %x - %50 = OpBitwiseAnd %v3uint %47 %49 - %46 = OpINotEqual %v3bool %50 %20 - %45 = OpSelect %v3uint %46 %30 %52 - %53 = OpLoad %v3uint %x - %54 = OpShiftRightLogical %v3uint %53 %45 - OpStore %x %54 - %57 = OpLoad %v3uint %x - %60 = OpBitwiseAnd %v3uint %57 %59 - %56 = OpINotEqual %v3bool %60 %20 - %55 = OpSelect %v3uint %56 %30 %62 - %63 = OpLoad %v3uint %x - %64 = OpShiftRightLogical %v3uint %63 %55 - OpStore %x %64 - %67 = OpLoad %v3uint %x - %70 = OpBitwiseAnd %v3uint %67 %69 - %66 = OpINotEqual %v3bool %70 %20 - %65 = OpSelect %v3uint %66 %30 %69 - %72 = OpLoad %v3uint %x - %73 = OpIEqual %v3bool %72 %30 - %71 = OpSelect %v3uint %73 %75 %30 - %77 = OpBitwiseOr %v3uint %21 %35 - %78 = OpBitwiseOr %v3uint %77 %45 - %79 = OpBitwiseOr %v3uint %78 %55 - %80 = OpBitwiseOr %v3uint %79 %65 - %81 = OpBitwiseOr %v3uint %80 %71 - %76 = OpBitcast %v3int %81 - OpReturnValue %76 + %21 = OpSelect %v3uint %22 %20 %30 + %31 = OpLoad %v3uint %x + %32 = OpShiftRightLogical %v3uint %31 %21 + OpStore %x %32 + %35 = OpLoad %v3uint %x + %38 = OpBitwiseAnd %v3uint %35 %37 + %34 = OpINotEqual %v3bool %38 %20 + %33 = OpSelect %v3uint %34 %20 %40 + %41 = OpLoad %v3uint %x + %42 = OpShiftRightLogical %v3uint %41 %33 + OpStore %x %42 + %45 = OpLoad %v3uint %x + %48 = OpBitwiseAnd %v3uint %45 %47 + %44 = OpINotEqual %v3bool %48 %20 + %43 = OpSelect %v3uint %44 %20 %50 + %51 = OpLoad %v3uint %x + %52 = OpShiftRightLogical %v3uint %51 %43 + OpStore %x %52 + %55 = OpLoad %v3uint %x + %58 = OpBitwiseAnd %v3uint %55 %57 + %54 = OpINotEqual %v3bool %58 %20 + %53 = OpSelect %v3uint %54 %20 %60 + %61 = OpLoad %v3uint %x + %62 = OpShiftRightLogical %v3uint %61 %53 + OpStore %x %62 + %65 = OpLoad %v3uint %x + %68 = OpBitwiseAnd %v3uint %65 %67 + %64 = OpINotEqual %v3bool %68 %20 + %63 = OpSelect %v3uint %64 %20 %67 + %70 = OpLoad %v3uint %x + %71 = OpIEqual %v3bool %70 %20 + %69 = OpSelect %v3uint %71 %73 %20 + %75 = OpBitwiseOr %v3uint %21 %33 + %76 = OpBitwiseOr %v3uint %75 %43 + %77 = OpBitwiseOr %v3uint %76 %53 + %78 = OpBitwiseOr %v3uint %77 %63 + %79 = OpBitwiseOr %v3uint %78 %69 + %74 = OpBitcast %v3int %79 + OpReturnValue %74 OpFunctionEnd -%firstTrailingBit_7496d6 = OpFunction %void None %82 - %85 = OpLabel - %res = OpVariable %_ptr_Function_v3int Function %87 - %86 = OpFunctionCall %v3int %tint_first_trailing_bit %87 - OpStore %res %86 +%firstTrailingBit_7496d6 = OpFunction %void None %80 + %83 = OpLabel + %res = OpVariable %_ptr_Function_v3int Function %85 + %84 = OpFunctionCall %v3int %tint_first_trailing_bit %85 + OpStore %res %84 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %90 - %92 = OpLabel - %93 = OpFunctionCall %void %firstTrailingBit_7496d6 +%vertex_main_inner = OpFunction %v4float None %88 + %90 = OpLabel + %91 = OpFunctionCall %void %firstTrailingBit_7496d6 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %82 - %95 = OpLabel - %96 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %96 +%vertex_main = OpFunction %void None %80 + %93 = OpLabel + %94 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %94 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %82 - %99 = OpLabel - %100 = OpFunctionCall %void %firstTrailingBit_7496d6 +%fragment_main = OpFunction %void None %80 + %97 = OpLabel + %98 = OpFunctionCall %void %firstTrailingBit_7496d6 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %82 - %102 = OpLabel - %103 = OpFunctionCall %void %firstTrailingBit_7496d6 +%compute_main = OpFunction %void None %80 + %100 = OpLabel + %101 = OpFunctionCall %void %firstTrailingBit_7496d6 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/firstTrailingBit/86551b.wgsl.expected.spvasm b/test/tint/builtins/gen/firstTrailingBit/86551b.wgsl.expected.spvasm index 7e4e821058..1e44e0a0d3 100644 --- a/test/tint/builtins/gen/firstTrailingBit/86551b.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/firstTrailingBit/86551b.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 104 +; Bound: 102 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -42,31 +42,29 @@ %v4bool = OpTypeVector %bool 4 %uint_65535 = OpConstant %uint 65535 %27 = OpConstantComposite %v4uint %uint_65535 %uint_65535 %uint_65535 %uint_65535 - %uint_0 = OpConstant %uint 0 - %30 = OpConstantComposite %v4uint %uint_0 %uint_0 %uint_0 %uint_0 %uint_16 = OpConstant %uint 16 - %32 = OpConstantComposite %v4uint %uint_16 %uint_16 %uint_16 %uint_16 + %30 = OpConstantComposite %v4uint %uint_16 %uint_16 %uint_16 %uint_16 %uint_255 = OpConstant %uint 255 - %39 = OpConstantComposite %v4uint %uint_255 %uint_255 %uint_255 %uint_255 + %37 = OpConstantComposite %v4uint %uint_255 %uint_255 %uint_255 %uint_255 %uint_8 = OpConstant %uint 8 - %42 = OpConstantComposite %v4uint %uint_8 %uint_8 %uint_8 %uint_8 + %40 = OpConstantComposite %v4uint %uint_8 %uint_8 %uint_8 %uint_8 %uint_15 = OpConstant %uint 15 - %49 = OpConstantComposite %v4uint %uint_15 %uint_15 %uint_15 %uint_15 + %47 = OpConstantComposite %v4uint %uint_15 %uint_15 %uint_15 %uint_15 %uint_4 = OpConstant %uint 4 - %52 = OpConstantComposite %v4uint %uint_4 %uint_4 %uint_4 %uint_4 + %50 = OpConstantComposite %v4uint %uint_4 %uint_4 %uint_4 %uint_4 %uint_3 = OpConstant %uint 3 - %59 = OpConstantComposite %v4uint %uint_3 %uint_3 %uint_3 %uint_3 + %57 = OpConstantComposite %v4uint %uint_3 %uint_3 %uint_3 %uint_3 %uint_2 = OpConstant %uint 2 - %62 = OpConstantComposite %v4uint %uint_2 %uint_2 %uint_2 %uint_2 + %60 = OpConstantComposite %v4uint %uint_2 %uint_2 %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %69 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 + %67 = OpConstantComposite %v4uint %uint_1 %uint_1 %uint_1 %uint_1 %uint_4294967295 = OpConstant %uint 4294967295 - %75 = OpConstantComposite %v4uint %uint_4294967295 %uint_4294967295 %uint_4294967295 %uint_4294967295 + %73 = OpConstantComposite %v4uint %uint_4294967295 %uint_4294967295 %uint_4294967295 %uint_4294967295 %void = OpTypeVoid - %82 = OpTypeFunction %void - %87 = OpConstantNull %v4int + %80 = OpTypeFunction %void + %85 = OpConstantNull %v4int %_ptr_Function_v4int = OpTypePointer Function %v4int - %90 = OpTypeFunction %v4float + %88 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_first_trailing_bit = OpFunction %v4int None %9 %v = OpFunctionParameter %v4int @@ -77,72 +75,72 @@ %25 = OpLoad %v4uint %x %28 = OpBitwiseAnd %v4uint %25 %27 %22 = OpINotEqual %v4bool %28 %20 - %21 = OpSelect %v4uint %22 %30 %32 - %33 = OpLoad %v4uint %x - %34 = OpShiftRightLogical %v4uint %33 %21 - OpStore %x %34 - %37 = OpLoad %v4uint %x - %40 = OpBitwiseAnd %v4uint %37 %39 - %36 = OpINotEqual %v4bool %40 %20 - %35 = OpSelect %v4uint %36 %30 %42 - %43 = OpLoad %v4uint %x - %44 = OpShiftRightLogical %v4uint %43 %35 - OpStore %x %44 - %47 = OpLoad %v4uint %x - %50 = OpBitwiseAnd %v4uint %47 %49 - %46 = OpINotEqual %v4bool %50 %20 - %45 = OpSelect %v4uint %46 %30 %52 - %53 = OpLoad %v4uint %x - %54 = OpShiftRightLogical %v4uint %53 %45 - OpStore %x %54 - %57 = OpLoad %v4uint %x - %60 = OpBitwiseAnd %v4uint %57 %59 - %56 = OpINotEqual %v4bool %60 %20 - %55 = OpSelect %v4uint %56 %30 %62 - %63 = OpLoad %v4uint %x - %64 = OpShiftRightLogical %v4uint %63 %55 - OpStore %x %64 - %67 = OpLoad %v4uint %x - %70 = OpBitwiseAnd %v4uint %67 %69 - %66 = OpINotEqual %v4bool %70 %20 - %65 = OpSelect %v4uint %66 %30 %69 - %72 = OpLoad %v4uint %x - %73 = OpIEqual %v4bool %72 %30 - %71 = OpSelect %v4uint %73 %75 %30 - %77 = OpBitwiseOr %v4uint %21 %35 - %78 = OpBitwiseOr %v4uint %77 %45 - %79 = OpBitwiseOr %v4uint %78 %55 - %80 = OpBitwiseOr %v4uint %79 %65 - %81 = OpBitwiseOr %v4uint %80 %71 - %76 = OpBitcast %v4int %81 - OpReturnValue %76 + %21 = OpSelect %v4uint %22 %20 %30 + %31 = OpLoad %v4uint %x + %32 = OpShiftRightLogical %v4uint %31 %21 + OpStore %x %32 + %35 = OpLoad %v4uint %x + %38 = OpBitwiseAnd %v4uint %35 %37 + %34 = OpINotEqual %v4bool %38 %20 + %33 = OpSelect %v4uint %34 %20 %40 + %41 = OpLoad %v4uint %x + %42 = OpShiftRightLogical %v4uint %41 %33 + OpStore %x %42 + %45 = OpLoad %v4uint %x + %48 = OpBitwiseAnd %v4uint %45 %47 + %44 = OpINotEqual %v4bool %48 %20 + %43 = OpSelect %v4uint %44 %20 %50 + %51 = OpLoad %v4uint %x + %52 = OpShiftRightLogical %v4uint %51 %43 + OpStore %x %52 + %55 = OpLoad %v4uint %x + %58 = OpBitwiseAnd %v4uint %55 %57 + %54 = OpINotEqual %v4bool %58 %20 + %53 = OpSelect %v4uint %54 %20 %60 + %61 = OpLoad %v4uint %x + %62 = OpShiftRightLogical %v4uint %61 %53 + OpStore %x %62 + %65 = OpLoad %v4uint %x + %68 = OpBitwiseAnd %v4uint %65 %67 + %64 = OpINotEqual %v4bool %68 %20 + %63 = OpSelect %v4uint %64 %20 %67 + %70 = OpLoad %v4uint %x + %71 = OpIEqual %v4bool %70 %20 + %69 = OpSelect %v4uint %71 %73 %20 + %75 = OpBitwiseOr %v4uint %21 %33 + %76 = OpBitwiseOr %v4uint %75 %43 + %77 = OpBitwiseOr %v4uint %76 %53 + %78 = OpBitwiseOr %v4uint %77 %63 + %79 = OpBitwiseOr %v4uint %78 %69 + %74 = OpBitcast %v4int %79 + OpReturnValue %74 OpFunctionEnd -%firstTrailingBit_86551b = OpFunction %void None %82 - %85 = OpLabel - %res = OpVariable %_ptr_Function_v4int Function %87 - %86 = OpFunctionCall %v4int %tint_first_trailing_bit %87 - OpStore %res %86 +%firstTrailingBit_86551b = OpFunction %void None %80 + %83 = OpLabel + %res = OpVariable %_ptr_Function_v4int Function %85 + %84 = OpFunctionCall %v4int %tint_first_trailing_bit %85 + OpStore %res %84 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %90 - %92 = OpLabel - %93 = OpFunctionCall %void %firstTrailingBit_86551b +%vertex_main_inner = OpFunction %v4float None %88 + %90 = OpLabel + %91 = OpFunctionCall %void %firstTrailingBit_86551b OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %82 - %95 = OpLabel - %96 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %96 +%vertex_main = OpFunction %void None %80 + %93 = OpLabel + %94 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %94 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %82 - %99 = OpLabel - %100 = OpFunctionCall %void %firstTrailingBit_86551b +%fragment_main = OpFunction %void None %80 + %97 = OpLabel + %98 = OpFunctionCall %void %firstTrailingBit_86551b OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %82 - %102 = OpLabel - %103 = OpFunctionCall %void %firstTrailingBit_86551b +%compute_main = OpFunction %void None %80 + %100 = OpLabel + %101 = OpFunctionCall %void %firstTrailingBit_86551b OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/firstTrailingBit/cb51ce.wgsl.expected.spvasm b/test/tint/builtins/gen/firstTrailingBit/cb51ce.wgsl.expected.spvasm index 4bcc0c73bc..b89d2f59ba 100644 --- a/test/tint/builtins/gen/firstTrailingBit/cb51ce.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/firstTrailingBit/cb51ce.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 100 +; Bound: 98 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -40,29 +40,27 @@ %v3bool = OpTypeVector %bool 3 %uint_65535 = OpConstant %uint 65535 %25 = OpConstantComposite %v3uint %uint_65535 %uint_65535 %uint_65535 - %uint_0 = OpConstant %uint 0 - %28 = OpConstantComposite %v3uint %uint_0 %uint_0 %uint_0 %uint_16 = OpConstant %uint 16 - %30 = OpConstantComposite %v3uint %uint_16 %uint_16 %uint_16 + %28 = OpConstantComposite %v3uint %uint_16 %uint_16 %uint_16 %uint_255 = OpConstant %uint 255 - %37 = OpConstantComposite %v3uint %uint_255 %uint_255 %uint_255 + %35 = OpConstantComposite %v3uint %uint_255 %uint_255 %uint_255 %uint_8 = OpConstant %uint 8 - %40 = OpConstantComposite %v3uint %uint_8 %uint_8 %uint_8 + %38 = OpConstantComposite %v3uint %uint_8 %uint_8 %uint_8 %uint_15 = OpConstant %uint 15 - %47 = OpConstantComposite %v3uint %uint_15 %uint_15 %uint_15 + %45 = OpConstantComposite %v3uint %uint_15 %uint_15 %uint_15 %uint_4 = OpConstant %uint 4 - %50 = OpConstantComposite %v3uint %uint_4 %uint_4 %uint_4 + %48 = OpConstantComposite %v3uint %uint_4 %uint_4 %uint_4 %uint_3 = OpConstant %uint 3 - %57 = OpConstantComposite %v3uint %uint_3 %uint_3 %uint_3 + %55 = OpConstantComposite %v3uint %uint_3 %uint_3 %uint_3 %uint_2 = OpConstant %uint 2 - %60 = OpConstantComposite %v3uint %uint_2 %uint_2 %uint_2 + %58 = OpConstantComposite %v3uint %uint_2 %uint_2 %uint_2 %uint_1 = OpConstant %uint 1 - %67 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 + %65 = OpConstantComposite %v3uint %uint_1 %uint_1 %uint_1 %uint_4294967295 = OpConstant %uint 4294967295 - %73 = OpConstantComposite %v3uint %uint_4294967295 %uint_4294967295 %uint_4294967295 + %71 = OpConstantComposite %v3uint %uint_4294967295 %uint_4294967295 %uint_4294967295 %void = OpTypeVoid - %80 = OpTypeFunction %void - %86 = OpTypeFunction %v4float + %78 = OpTypeFunction %void + %84 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %tint_first_trailing_bit = OpFunction %v3uint None %9 %v = OpFunctionParameter %v3uint @@ -72,71 +70,71 @@ %23 = OpLoad %v3uint %x %26 = OpBitwiseAnd %v3uint %23 %25 %20 = OpINotEqual %v3bool %26 %18 - %19 = OpSelect %v3uint %20 %28 %30 - %31 = OpLoad %v3uint %x - %32 = OpShiftRightLogical %v3uint %31 %19 - OpStore %x %32 - %35 = OpLoad %v3uint %x - %38 = OpBitwiseAnd %v3uint %35 %37 - %34 = OpINotEqual %v3bool %38 %18 - %33 = OpSelect %v3uint %34 %28 %40 - %41 = OpLoad %v3uint %x - %42 = OpShiftRightLogical %v3uint %41 %33 - OpStore %x %42 - %45 = OpLoad %v3uint %x - %48 = OpBitwiseAnd %v3uint %45 %47 - %44 = OpINotEqual %v3bool %48 %18 - %43 = OpSelect %v3uint %44 %28 %50 - %51 = OpLoad %v3uint %x - %52 = OpShiftRightLogical %v3uint %51 %43 - OpStore %x %52 - %55 = OpLoad %v3uint %x - %58 = OpBitwiseAnd %v3uint %55 %57 - %54 = OpINotEqual %v3bool %58 %18 - %53 = OpSelect %v3uint %54 %28 %60 - %61 = OpLoad %v3uint %x - %62 = OpShiftRightLogical %v3uint %61 %53 - OpStore %x %62 - %65 = OpLoad %v3uint %x - %68 = OpBitwiseAnd %v3uint %65 %67 - %64 = OpINotEqual %v3bool %68 %18 - %63 = OpSelect %v3uint %64 %28 %67 - %70 = OpLoad %v3uint %x - %71 = OpIEqual %v3bool %70 %28 - %69 = OpSelect %v3uint %71 %73 %28 - %75 = OpBitwiseOr %v3uint %19 %33 - %76 = OpBitwiseOr %v3uint %75 %43 - %77 = OpBitwiseOr %v3uint %76 %53 - %78 = OpBitwiseOr %v3uint %77 %63 - %79 = OpBitwiseOr %v3uint %78 %69 - OpReturnValue %79 + %19 = OpSelect %v3uint %20 %18 %28 + %29 = OpLoad %v3uint %x + %30 = OpShiftRightLogical %v3uint %29 %19 + OpStore %x %30 + %33 = OpLoad %v3uint %x + %36 = OpBitwiseAnd %v3uint %33 %35 + %32 = OpINotEqual %v3bool %36 %18 + %31 = OpSelect %v3uint %32 %18 %38 + %39 = OpLoad %v3uint %x + %40 = OpShiftRightLogical %v3uint %39 %31 + OpStore %x %40 + %43 = OpLoad %v3uint %x + %46 = OpBitwiseAnd %v3uint %43 %45 + %42 = OpINotEqual %v3bool %46 %18 + %41 = OpSelect %v3uint %42 %18 %48 + %49 = OpLoad %v3uint %x + %50 = OpShiftRightLogical %v3uint %49 %41 + OpStore %x %50 + %53 = OpLoad %v3uint %x + %56 = OpBitwiseAnd %v3uint %53 %55 + %52 = OpINotEqual %v3bool %56 %18 + %51 = OpSelect %v3uint %52 %18 %58 + %59 = OpLoad %v3uint %x + %60 = OpShiftRightLogical %v3uint %59 %51 + OpStore %x %60 + %63 = OpLoad %v3uint %x + %66 = OpBitwiseAnd %v3uint %63 %65 + %62 = OpINotEqual %v3bool %66 %18 + %61 = OpSelect %v3uint %62 %18 %65 + %68 = OpLoad %v3uint %x + %69 = OpIEqual %v3bool %68 %18 + %67 = OpSelect %v3uint %69 %71 %18 + %73 = OpBitwiseOr %v3uint %19 %31 + %74 = OpBitwiseOr %v3uint %73 %41 + %75 = OpBitwiseOr %v3uint %74 %51 + %76 = OpBitwiseOr %v3uint %75 %61 + %77 = OpBitwiseOr %v3uint %76 %67 + OpReturnValue %77 OpFunctionEnd -%firstTrailingBit_cb51ce = OpFunction %void None %80 - %83 = OpLabel +%firstTrailingBit_cb51ce = OpFunction %void None %78 + %81 = OpLabel %res = OpVariable %_ptr_Function_v3uint Function %18 - %84 = OpFunctionCall %v3uint %tint_first_trailing_bit %18 - OpStore %res %84 + %82 = OpFunctionCall %v3uint %tint_first_trailing_bit %18 + OpStore %res %82 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %86 - %88 = OpLabel - %89 = OpFunctionCall %void %firstTrailingBit_cb51ce +%vertex_main_inner = OpFunction %v4float None %84 + %86 = OpLabel + %87 = OpFunctionCall %void %firstTrailingBit_cb51ce OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %80 - %91 = OpLabel - %92 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %92 +%vertex_main = OpFunction %void None %78 + %89 = OpLabel + %90 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %90 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %80 - %95 = OpLabel - %96 = OpFunctionCall %void %firstTrailingBit_cb51ce +%fragment_main = OpFunction %void None %78 + %93 = OpLabel + %94 = OpFunctionCall %void %firstTrailingBit_cb51ce OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %80 - %98 = OpLabel - %99 = OpFunctionCall %void %firstTrailingBit_cb51ce +%compute_main = OpFunction %void None %78 + %96 = OpLabel + %97 = OpFunctionCall %void %firstTrailingBit_cb51ce OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureDimensions/12c9bb.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/12c9bb.wgsl.expected.spvasm index 82f66a740b..18c8dbe6c5 100644 --- a/test/tint/builtins/gen/textureDimensions/12c9bb.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/12c9bb.wgsl.expected.spvasm @@ -39,7 +39,7 @@ %12 = OpTypeFunction %void %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 - %int_0 = OpConstant %int 0 + %20 = OpConstantNull %int %_ptr_Function_v2int = OpTypePointer Function %v2int %23 = OpConstantNull %v2int %24 = OpTypeFunction %v4float @@ -48,7 +48,7 @@ %15 = OpLabel %res = OpVariable %_ptr_Function_v2int Function %23 %19 = OpLoad %11 %arg_0 - %16 = OpImageQuerySizeLod %v2int %19 %int_0 + %16 = OpImageQuerySizeLod %v2int %19 %20 OpStore %res %16 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureDimensions/221f22.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/221f22.wgsl.expected.spvasm index 527024f3f5..4485240604 100644 --- a/test/tint/builtins/gen/textureDimensions/221f22.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/221f22.wgsl.expected.spvasm @@ -41,7 +41,7 @@ %13 = OpTypeFunction %void %v2int = OpTypeVector %int 2 %v3int = OpTypeVector %int 3 - %int_0 = OpConstant %int 0 + %22 = OpConstantNull %int %_ptr_Function_v2int = OpTypePointer Function %v2int %25 = OpConstantNull %v2int %26 = OpTypeFunction %v4float @@ -50,7 +50,7 @@ %16 = OpLabel %res = OpVariable %_ptr_Function_v2int Function %25 %21 = OpLoad %11 %arg_0 - %19 = OpImageQuerySizeLod %v3int %21 %int_0 + %19 = OpImageQuerySizeLod %v3int %21 %22 %17 = OpVectorShuffle %v2int %19 %19 0 1 OpStore %res %17 OpReturn diff --git a/test/tint/builtins/gen/textureDimensions/267788.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/267788.wgsl.expected.spvasm index 7c1f7de6c9..f9410bc89a 100644 --- a/test/tint/builtins/gen/textureDimensions/267788.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/267788.wgsl.expected.spvasm @@ -41,7 +41,7 @@ %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %v3int = OpTypeVector %int 3 - %int_0 = OpConstant %int 0 + %23 = OpConstantNull %int %_ptr_Function_v2int = OpTypePointer Function %v2int %26 = OpConstantNull %v2int %27 = OpTypeFunction %v4float @@ -50,7 +50,7 @@ %16 = OpLabel %res = OpVariable %_ptr_Function_v2int Function %26 %22 = OpLoad %11 %arg_0 - %20 = OpImageQuerySizeLod %v3int %22 %int_0 + %20 = OpImageQuerySizeLod %v3int %22 %23 %17 = OpVectorShuffle %v2int %20 %20 0 1 OpStore %res %17 OpReturn diff --git a/test/tint/builtins/gen/textureDimensions/26bdfa.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/26bdfa.wgsl.expected.spvasm index dda3b4f083..2c48480271 100644 --- a/test/tint/builtins/gen/textureDimensions/26bdfa.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/26bdfa.wgsl.expected.spvasm @@ -39,7 +39,7 @@ %12 = OpTypeFunction %void %int = OpTypeInt 32 1 %v3int = OpTypeVector %int 3 - %int_0 = OpConstant %int 0 + %20 = OpConstantNull %int %_ptr_Function_v3int = OpTypePointer Function %v3int %23 = OpConstantNull %v3int %24 = OpTypeFunction %v4float @@ -48,7 +48,7 @@ %15 = OpLabel %res = OpVariable %_ptr_Function_v3int Function %23 %19 = OpLoad %11 %arg_0 - %16 = OpImageQuerySizeLod %v3int %19 %int_0 + %16 = OpImageQuerySizeLod %v3int %19 %20 OpStore %res %16 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureDimensions/2efa05.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/2efa05.wgsl.expected.spvasm index 3293c2788e..6a22b83296 100644 --- a/test/tint/builtins/gen/textureDimensions/2efa05.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/2efa05.wgsl.expected.spvasm @@ -40,7 +40,7 @@ %13 = OpTypeFunction %void %int = OpTypeInt 32 1 %v3int = OpTypeVector %int 3 - %int_0 = OpConstant %int 0 + %21 = OpConstantNull %int %_ptr_Function_v3int = OpTypePointer Function %v3int %24 = OpConstantNull %v3int %25 = OpTypeFunction %v4float @@ -49,7 +49,7 @@ %16 = OpLabel %res = OpVariable %_ptr_Function_v3int Function %24 %20 = OpLoad %11 %arg_0 - %17 = OpImageQuerySizeLod %v3int %20 %int_0 + %17 = OpImageQuerySizeLod %v3int %20 %21 OpStore %res %17 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureDimensions/2fe1cc.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/2fe1cc.wgsl.expected.spvasm index a95be9ef19..1d4dd98f5d 100644 --- a/test/tint/builtins/gen/textureDimensions/2fe1cc.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/2fe1cc.wgsl.expected.spvasm @@ -39,7 +39,7 @@ %12 = OpTypeFunction %void %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 - %int_0 = OpConstant %int 0 + %20 = OpConstantNull %int %_ptr_Function_v2int = OpTypePointer Function %v2int %23 = OpConstantNull %v2int %24 = OpTypeFunction %v4float @@ -48,7 +48,7 @@ %15 = OpLabel %res = OpVariable %_ptr_Function_v2int Function %23 %19 = OpLoad %11 %arg_0 - %16 = OpImageQuerySizeLod %v2int %19 %int_0 + %16 = OpImageQuerySizeLod %v2int %19 %20 OpStore %res %16 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureDimensions/50a9ee.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/50a9ee.wgsl.expected.spvasm index e0dd9de76f..e94074d2b1 100644 --- a/test/tint/builtins/gen/textureDimensions/50a9ee.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/50a9ee.wgsl.expected.spvasm @@ -41,7 +41,7 @@ %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %v3int = OpTypeVector %int 3 - %int_0 = OpConstant %int 0 + %22 = OpConstantNull %int %_ptr_Function_v2int = OpTypePointer Function %v2int %25 = OpConstantNull %v2int %26 = OpTypeFunction %v4float @@ -50,7 +50,7 @@ %15 = OpLabel %res = OpVariable %_ptr_Function_v2int Function %25 %21 = OpLoad %11 %arg_0 - %19 = OpImageQuerySizeLod %v3int %21 %int_0 + %19 = OpImageQuerySizeLod %v3int %21 %22 %16 = OpVectorShuffle %v2int %19 %19 0 1 OpStore %res %16 OpReturn diff --git a/test/tint/builtins/gen/textureDimensions/52045c.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/52045c.wgsl.expected.spvasm index 2d27a40254..b8f51b1501 100644 --- a/test/tint/builtins/gen/textureDimensions/52045c.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/52045c.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 37 +; Bound: 36 ; Schema: 0 OpCapability Shader OpCapability Sampled1D @@ -39,38 +39,37 @@ %arg_0 = OpVariable %_ptr_UniformConstant_11 UniformConstant %void = OpTypeVoid %13 = OpTypeFunction %void - %int_0 = OpConstant %int 0 + %19 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %22 = OpConstantNull %int - %23 = OpTypeFunction %v4float + %22 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %textureDimensions_52045c = OpFunction %void None %13 %16 = OpLabel - %res = OpVariable %_ptr_Function_int Function %22 + %res = OpVariable %_ptr_Function_int Function %19 %18 = OpLoad %11 %arg_0 - %17 = OpImageQuerySizeLod %int %18 %int_0 + %17 = OpImageQuerySizeLod %int %18 %19 OpStore %res %17 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %23 - %25 = OpLabel - %26 = OpFunctionCall %void %textureDimensions_52045c +%vertex_main_inner = OpFunction %v4float None %22 + %24 = OpLabel + %25 = OpFunctionCall %void %textureDimensions_52045c OpReturnValue %5 OpFunctionEnd %vertex_main = OpFunction %void None %13 - %28 = OpLabel - %29 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %29 + %27 = OpLabel + %28 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %28 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd %fragment_main = OpFunction %void None %13 - %32 = OpLabel - %33 = OpFunctionCall %void %textureDimensions_52045c + %31 = OpLabel + %32 = OpFunctionCall %void %textureDimensions_52045c OpReturn OpFunctionEnd %compute_main = OpFunction %void None %13 - %35 = OpLabel - %36 = OpFunctionCall %void %textureDimensions_52045c + %34 = OpLabel + %35 = OpFunctionCall %void %textureDimensions_52045c OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureDimensions/686ef2.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/686ef2.wgsl.expected.spvasm index 90a2379cec..d18fd5a4b1 100644 --- a/test/tint/builtins/gen/textureDimensions/686ef2.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/686ef2.wgsl.expected.spvasm @@ -39,7 +39,7 @@ %void = OpTypeVoid %13 = OpTypeFunction %void %v2int = OpTypeVector %int 2 - %int_0 = OpConstant %int 0 + %20 = OpConstantNull %int %_ptr_Function_v2int = OpTypePointer Function %v2int %23 = OpConstantNull %v2int %24 = OpTypeFunction %v4float @@ -48,7 +48,7 @@ %16 = OpLabel %res = OpVariable %_ptr_Function_v2int Function %23 %19 = OpLoad %11 %arg_0 - %17 = OpImageQuerySizeLod %v2int %19 %int_0 + %17 = OpImageQuerySizeLod %v2int %19 %20 OpStore %res %17 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureDimensions/72e5d6.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/72e5d6.wgsl.expected.spvasm index 7d2a40cd63..41744eed41 100644 --- a/test/tint/builtins/gen/textureDimensions/72e5d6.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/72e5d6.wgsl.expected.spvasm @@ -40,7 +40,7 @@ %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %v3int = OpTypeVector %int 3 - %int_0 = OpConstant %int 0 + %22 = OpConstantNull %int %_ptr_Function_v2int = OpTypePointer Function %v2int %25 = OpConstantNull %v2int %26 = OpTypeFunction %v4float @@ -49,7 +49,7 @@ %15 = OpLabel %res = OpVariable %_ptr_Function_v2int Function %25 %21 = OpLoad %11 %arg_0 - %19 = OpImageQuerySizeLod %v3int %21 %int_0 + %19 = OpImageQuerySizeLod %v3int %21 %22 %16 = OpVectorShuffle %v2int %19 %19 0 1 OpStore %res %16 OpReturn diff --git a/test/tint/builtins/gen/textureDimensions/79df87.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/79df87.wgsl.expected.spvasm index eaeb505522..0f51e098c2 100644 --- a/test/tint/builtins/gen/textureDimensions/79df87.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/79df87.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 38 +; Bound: 37 ; Schema: 0 OpCapability Shader OpCapability Sampled1D @@ -40,38 +40,37 @@ %void = OpTypeVoid %13 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %20 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %23 = OpConstantNull %int - %24 = OpTypeFunction %v4float + %23 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %textureDimensions_79df87 = OpFunction %void None %13 %16 = OpLabel - %res = OpVariable %_ptr_Function_int Function %23 + %res = OpVariable %_ptr_Function_int Function %20 %19 = OpLoad %11 %arg_0 - %17 = OpImageQuerySizeLod %int %19 %int_0 + %17 = OpImageQuerySizeLod %int %19 %20 OpStore %res %17 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %24 - %26 = OpLabel - %27 = OpFunctionCall %void %textureDimensions_79df87 +%vertex_main_inner = OpFunction %v4float None %23 + %25 = OpLabel + %26 = OpFunctionCall %void %textureDimensions_79df87 OpReturnValue %5 OpFunctionEnd %vertex_main = OpFunction %void None %13 - %29 = OpLabel - %30 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %30 + %28 = OpLabel + %29 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %29 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd %fragment_main = OpFunction %void None %13 - %33 = OpLabel - %34 = OpFunctionCall %void %textureDimensions_79df87 + %32 = OpLabel + %33 = OpFunctionCall %void %textureDimensions_79df87 OpReturn OpFunctionEnd %compute_main = OpFunction %void None %13 - %36 = OpLabel - %37 = OpFunctionCall %void %textureDimensions_79df87 + %35 = OpLabel + %36 = OpFunctionCall %void %textureDimensions_79df87 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureDimensions/85d556.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/85d556.wgsl.expected.spvasm index c0284956dc..8e1e2f3017 100644 --- a/test/tint/builtins/gen/textureDimensions/85d556.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/85d556.wgsl.expected.spvasm @@ -40,7 +40,7 @@ %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %v3int = OpTypeVector %int 3 - %int_0 = OpConstant %int 0 + %22 = OpConstantNull %int %_ptr_Function_v2int = OpTypePointer Function %v2int %25 = OpConstantNull %v2int %26 = OpTypeFunction %v4float @@ -49,7 +49,7 @@ %15 = OpLabel %res = OpVariable %_ptr_Function_v2int Function %25 %21 = OpLoad %11 %arg_0 - %19 = OpImageQuerySizeLod %v3int %21 %int_0 + %19 = OpImageQuerySizeLod %v3int %21 %22 %16 = OpVectorShuffle %v2int %19 %19 0 1 OpStore %res %16 OpReturn diff --git a/test/tint/builtins/gen/textureDimensions/88ad17.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/88ad17.wgsl.expected.spvasm index a16d7641ab..8c53fccb78 100644 --- a/test/tint/builtins/gen/textureDimensions/88ad17.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/88ad17.wgsl.expected.spvasm @@ -40,7 +40,7 @@ %13 = OpTypeFunction %void %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 - %int_0 = OpConstant %int 0 + %21 = OpConstantNull %int %_ptr_Function_v2int = OpTypePointer Function %v2int %24 = OpConstantNull %v2int %25 = OpTypeFunction %v4float @@ -49,7 +49,7 @@ %16 = OpLabel %res = OpVariable %_ptr_Function_v2int Function %24 %20 = OpLoad %11 %arg_0 - %17 = OpImageQuerySizeLod %v2int %20 %int_0 + %17 = OpImageQuerySizeLod %v2int %20 %21 OpStore %res %17 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureDimensions/9393b0.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/9393b0.wgsl.expected.spvasm index 4ce2ce17ea..55a246581b 100644 --- a/test/tint/builtins/gen/textureDimensions/9393b0.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/9393b0.wgsl.expected.spvasm @@ -39,7 +39,7 @@ %12 = OpTypeFunction %void %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 - %int_0 = OpConstant %int 0 + %20 = OpConstantNull %int %_ptr_Function_v2int = OpTypePointer Function %v2int %23 = OpConstantNull %v2int %24 = OpTypeFunction %v4float @@ -48,7 +48,7 @@ %15 = OpLabel %res = OpVariable %_ptr_Function_v2int Function %23 %19 = OpLoad %11 %arg_0 - %16 = OpImageQuerySizeLod %v2int %19 %int_0 + %16 = OpImageQuerySizeLod %v2int %19 %20 OpStore %res %16 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureDimensions/9c9c57.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/9c9c57.wgsl.expected.spvasm index 6d34f924d3..4dfce52afe 100644 --- a/test/tint/builtins/gen/textureDimensions/9c9c57.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/9c9c57.wgsl.expected.spvasm @@ -40,7 +40,7 @@ %13 = OpTypeFunction %void %v2int = OpTypeVector %int 2 %v3int = OpTypeVector %int 3 - %int_0 = OpConstant %int 0 + %22 = OpConstantNull %int %_ptr_Function_v2int = OpTypePointer Function %v2int %25 = OpConstantNull %v2int %26 = OpTypeFunction %v4float @@ -49,7 +49,7 @@ %16 = OpLabel %res = OpVariable %_ptr_Function_v2int Function %25 %21 = OpLoad %11 %arg_0 - %19 = OpImageQuerySizeLod %v3int %21 %int_0 + %19 = OpImageQuerySizeLod %v3int %21 %22 %17 = OpVectorShuffle %v2int %19 %19 0 1 OpStore %res %17 OpReturn diff --git a/test/tint/builtins/gen/textureDimensions/a01845.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/a01845.wgsl.expected.spvasm index 1cf408faa5..93cf0664d7 100644 --- a/test/tint/builtins/gen/textureDimensions/a01845.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/a01845.wgsl.expected.spvasm @@ -41,7 +41,7 @@ %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %v3int = OpTypeVector %int 3 - %int_0 = OpConstant %int 0 + %22 = OpConstantNull %int %_ptr_Function_v2int = OpTypePointer Function %v2int %25 = OpConstantNull %v2int %26 = OpTypeFunction %v4float @@ -50,7 +50,7 @@ %15 = OpLabel %res = OpVariable %_ptr_Function_v2int Function %25 %21 = OpLoad %11 %arg_0 - %19 = OpImageQuerySizeLod %v3int %21 %int_0 + %19 = OpImageQuerySizeLod %v3int %21 %22 %16 = OpVectorShuffle %v2int %19 %19 0 1 OpStore %res %16 OpReturn diff --git a/test/tint/builtins/gen/textureDimensions/a9c9c1.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/a9c9c1.wgsl.expected.spvasm index a075354ade..cc8c579afe 100644 --- a/test/tint/builtins/gen/textureDimensions/a9c9c1.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/a9c9c1.wgsl.expected.spvasm @@ -39,7 +39,7 @@ %12 = OpTypeFunction %void %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 - %int_0 = OpConstant %int 0 + %20 = OpConstantNull %int %_ptr_Function_v2int = OpTypePointer Function %v2int %23 = OpConstantNull %v2int %24 = OpTypeFunction %v4float @@ -48,7 +48,7 @@ %15 = OpLabel %res = OpVariable %_ptr_Function_v2int Function %23 %19 = OpLoad %11 %arg_0 - %16 = OpImageQuerySizeLod %v2int %19 %int_0 + %16 = OpImageQuerySizeLod %v2int %19 %20 OpStore %res %16 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureDimensions/b0e16d.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/b0e16d.wgsl.expected.spvasm index ce5229ce6f..5f4af76d81 100644 --- a/test/tint/builtins/gen/textureDimensions/b0e16d.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/b0e16d.wgsl.expected.spvasm @@ -39,7 +39,7 @@ %void = OpTypeVoid %13 = OpTypeFunction %void %v2int = OpTypeVector %int 2 - %int_0 = OpConstant %int 0 + %20 = OpConstantNull %int %_ptr_Function_v2int = OpTypePointer Function %v2int %23 = OpConstantNull %v2int %24 = OpTypeFunction %v4float @@ -48,7 +48,7 @@ %16 = OpLabel %res = OpVariable %_ptr_Function_v2int Function %23 %19 = OpLoad %11 %arg_0 - %17 = OpImageQuerySizeLod %v2int %19 %int_0 + %17 = OpImageQuerySizeLod %v2int %19 %20 OpStore %res %17 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureDimensions/b3e407.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/b3e407.wgsl.expected.spvasm index b700841b9f..15a6f7ca6f 100644 --- a/test/tint/builtins/gen/textureDimensions/b3e407.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/b3e407.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 37 +; Bound: 36 ; Schema: 0 OpCapability Shader OpCapability Sampled1D @@ -39,38 +39,37 @@ %void = OpTypeVoid %12 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %19 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %22 = OpConstantNull %int - %23 = OpTypeFunction %v4float + %22 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %textureDimensions_b3e407 = OpFunction %void None %12 %15 = OpLabel - %res = OpVariable %_ptr_Function_int Function %22 + %res = OpVariable %_ptr_Function_int Function %19 %18 = OpLoad %11 %arg_0 - %16 = OpImageQuerySizeLod %int %18 %int_0 + %16 = OpImageQuerySizeLod %int %18 %19 OpStore %res %16 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %23 - %25 = OpLabel - %26 = OpFunctionCall %void %textureDimensions_b3e407 +%vertex_main_inner = OpFunction %v4float None %22 + %24 = OpLabel + %25 = OpFunctionCall %void %textureDimensions_b3e407 OpReturnValue %5 OpFunctionEnd %vertex_main = OpFunction %void None %12 - %28 = OpLabel - %29 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %29 + %27 = OpLabel + %28 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %28 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd %fragment_main = OpFunction %void None %12 - %32 = OpLabel - %33 = OpFunctionCall %void %textureDimensions_b3e407 + %31 = OpLabel + %32 = OpFunctionCall %void %textureDimensions_b3e407 OpReturn OpFunctionEnd %compute_main = OpFunction %void None %12 - %35 = OpLabel - %36 = OpFunctionCall %void %textureDimensions_b3e407 + %34 = OpLabel + %35 = OpFunctionCall %void %textureDimensions_b3e407 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureDimensions/d83c45.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/d83c45.wgsl.expected.spvasm index 8f98426621..d715d3cb99 100644 --- a/test/tint/builtins/gen/textureDimensions/d83c45.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/d83c45.wgsl.expected.spvasm @@ -42,7 +42,7 @@ %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %v3int = OpTypeVector %int 3 - %int_0 = OpConstant %int 0 + %23 = OpConstantNull %int %_ptr_Function_v2int = OpTypePointer Function %v2int %26 = OpConstantNull %v2int %27 = OpTypeFunction %v4float @@ -51,7 +51,7 @@ %16 = OpLabel %res = OpVariable %_ptr_Function_v2int Function %26 %22 = OpLoad %11 %arg_0 - %20 = OpImageQuerySizeLod %v3int %22 %int_0 + %20 = OpImageQuerySizeLod %v3int %22 %23 %17 = OpVectorShuffle %v2int %20 %20 0 1 OpStore %res %17 OpReturn diff --git a/test/tint/builtins/gen/textureDimensions/efc8a4.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/efc8a4.wgsl.expected.spvasm index c249a248dc..fe0d9a6f03 100644 --- a/test/tint/builtins/gen/textureDimensions/efc8a4.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/efc8a4.wgsl.expected.spvasm @@ -39,7 +39,7 @@ %void = OpTypeVoid %13 = OpTypeFunction %void %v3int = OpTypeVector %int 3 - %int_0 = OpConstant %int 0 + %20 = OpConstantNull %int %_ptr_Function_v3int = OpTypePointer Function %v3int %23 = OpConstantNull %v3int %24 = OpTypeFunction %v4float @@ -48,7 +48,7 @@ %16 = OpLabel %res = OpVariable %_ptr_Function_v3int Function %23 %19 = OpLoad %11 %arg_0 - %17 = OpImageQuerySizeLod %v3int %19 %int_0 + %17 = OpImageQuerySizeLod %v3int %19 %20 OpStore %res %17 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureDimensions/f7145b.wgsl.expected.spvasm b/test/tint/builtins/gen/textureDimensions/f7145b.wgsl.expected.spvasm index 7a5a016454..ed352accb7 100644 --- a/test/tint/builtins/gen/textureDimensions/f7145b.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureDimensions/f7145b.wgsl.expected.spvasm @@ -40,7 +40,7 @@ %13 = OpTypeFunction %void %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 - %int_0 = OpConstant %int 0 + %21 = OpConstantNull %int %_ptr_Function_v2int = OpTypePointer Function %v2int %24 = OpConstantNull %v2int %25 = OpTypeFunction %v4float @@ -49,7 +49,7 @@ %16 = OpLabel %res = OpVariable %_ptr_Function_v2int Function %24 %20 = OpLoad %11 %arg_0 - %17 = OpImageQuerySizeLod %v2int %20 %int_0 + %17 = OpImageQuerySizeLod %v2int %20 %21 OpStore %res %17 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureLoad/19cf87.wgsl.expected.spvasm b/test/tint/builtins/gen/textureLoad/19cf87.wgsl.expected.spvasm index eca642dfbb..e2f37597f8 100644 --- a/test/tint/builtins/gen/textureLoad/19cf87.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureLoad/19cf87.wgsl.expected.spvasm @@ -39,7 +39,7 @@ %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %21 = OpConstantNull %v2int - %int_0 = OpConstant %int 0 + %22 = OpConstantNull %int %_ptr_Function_float = OpTypePointer Function %float %25 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 @@ -47,7 +47,7 @@ %15 = OpLabel %res = OpVariable %_ptr_Function_float Function %8 %18 = OpLoad %11 %arg_0 - %17 = OpImageFetch %v4float %18 %21 Lod %int_0 + %17 = OpImageFetch %v4float %18 %21 Lod %22 %16 = OpCompositeExtract %float %17 0 OpStore %res %16 OpReturn diff --git a/test/tint/builtins/gen/textureLoad/1b8588.wgsl.expected.spvasm b/test/tint/builtins/gen/textureLoad/1b8588.wgsl.expected.spvasm index 21b4c1eeb9..cd22bbac76 100644 --- a/test/tint/builtins/gen/textureLoad/1b8588.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureLoad/1b8588.wgsl.expected.spvasm @@ -41,7 +41,7 @@ %v4uint = OpTypeVector %uint 4 %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 - %int_0 = OpConstant %int 0 + %22 = OpConstantNull %int %_ptr_Function_v4uint = OpTypePointer Function %v4uint %25 = OpConstantNull %v4uint %26 = OpTypeFunction %v4float @@ -50,7 +50,7 @@ %16 = OpLabel %res = OpVariable %_ptr_Function_v4uint Function %25 %19 = OpLoad %11 %arg_0 - %17 = OpImageFetch %v4uint %19 %int_1 Lod %int_0 + %17 = OpImageFetch %v4uint %19 %int_1 Lod %22 OpStore %res %17 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureLoad/1f2016.wgsl.expected.spvasm b/test/tint/builtins/gen/textureLoad/1f2016.wgsl.expected.spvasm index 15ceefac3b..13f8d2ac67 100644 --- a/test/tint/builtins/gen/textureLoad/1f2016.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureLoad/1f2016.wgsl.expected.spvasm @@ -39,7 +39,7 @@ %int = OpTypeInt 32 1 %v3int = OpTypeVector %int 3 %20 = OpConstantNull %v3int - %int_0 = OpConstant %int 0 + %21 = OpConstantNull %int %_ptr_Function_v4float = OpTypePointer Function %v4float %24 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 @@ -47,7 +47,7 @@ %15 = OpLabel %res = OpVariable %_ptr_Function_v4float Function %5 %17 = OpLoad %11 %arg_0 - %16 = OpImageFetch %v4float %17 %20 Lod %int_0 + %16 = OpImageFetch %v4float %17 %20 Lod %21 OpStore %res %16 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureLoad/484344.wgsl.expected.spvasm b/test/tint/builtins/gen/textureLoad/484344.wgsl.expected.spvasm index 5bf420135e..46e1f0855d 100644 --- a/test/tint/builtins/gen/textureLoad/484344.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureLoad/484344.wgsl.expected.spvasm @@ -39,7 +39,7 @@ %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %20 = OpConstantNull %v2int - %int_0 = OpConstant %int 0 + %21 = OpConstantNull %int %_ptr_Function_v4float = OpTypePointer Function %v4float %24 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 @@ -47,7 +47,7 @@ %15 = OpLabel %res = OpVariable %_ptr_Function_v4float Function %5 %17 = OpLoad %11 %arg_0 - %16 = OpImageFetch %v4float %17 %20 Lod %int_0 + %16 = OpImageFetch %v4float %17 %20 Lod %21 OpStore %res %16 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureLoad/4fd803.wgsl.expected.spvasm b/test/tint/builtins/gen/textureLoad/4fd803.wgsl.expected.spvasm index dae2d0c5fc..b830446b38 100644 --- a/test/tint/builtins/gen/textureLoad/4fd803.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureLoad/4fd803.wgsl.expected.spvasm @@ -40,7 +40,7 @@ %v4int = OpTypeVector %int 4 %v3int = OpTypeVector %int 3 %21 = OpConstantNull %v3int - %int_0 = OpConstant %int 0 + %22 = OpConstantNull %int %_ptr_Function_v4int = OpTypePointer Function %v4int %25 = OpConstantNull %v4int %26 = OpTypeFunction %v4float @@ -49,7 +49,7 @@ %16 = OpLabel %res = OpVariable %_ptr_Function_v4int Function %25 %19 = OpLoad %11 %arg_0 - %17 = OpImageFetch %v4int %19 %21 Lod %int_0 + %17 = OpImageFetch %v4int %19 %21 Lod %22 OpStore %res %17 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureLoad/5a2f9d.wgsl.expected.spvasm b/test/tint/builtins/gen/textureLoad/5a2f9d.wgsl.expected.spvasm index 3388593931..5d51595f19 100644 --- a/test/tint/builtins/gen/textureLoad/5a2f9d.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureLoad/5a2f9d.wgsl.expected.spvasm @@ -40,7 +40,7 @@ %13 = OpTypeFunction %void %v4int = OpTypeVector %int 4 %int_1 = OpConstant %int 1 - %int_0 = OpConstant %int 0 + %21 = OpConstantNull %int %_ptr_Function_v4int = OpTypePointer Function %v4int %24 = OpConstantNull %v4int %25 = OpTypeFunction %v4float @@ -49,7 +49,7 @@ %16 = OpLabel %res = OpVariable %_ptr_Function_v4int Function %24 %19 = OpLoad %11 %arg_0 - %17 = OpImageFetch %v4int %19 %int_1 Lod %int_0 + %17 = OpImageFetch %v4int %19 %int_1 Lod %21 OpStore %res %17 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureLoad/6154d4.wgsl.expected.spvasm b/test/tint/builtins/gen/textureLoad/6154d4.wgsl.expected.spvasm index 579e1d96cd..ad0a77ad54 100644 --- a/test/tint/builtins/gen/textureLoad/6154d4.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureLoad/6154d4.wgsl.expected.spvasm @@ -41,7 +41,7 @@ %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 %22 = OpConstantNull %v2int - %int_0 = OpConstant %int 0 + %23 = OpConstantNull %int %_ptr_Function_v4uint = OpTypePointer Function %v4uint %26 = OpConstantNull %v4uint %27 = OpTypeFunction %v4float @@ -50,7 +50,7 @@ %16 = OpLabel %res = OpVariable %_ptr_Function_v4uint Function %26 %19 = OpLoad %11 %arg_0 - %17 = OpImageFetch %v4uint %19 %22 Lod %int_0 + %17 = OpImageFetch %v4uint %19 %22 Lod %23 OpStore %res %17 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureLoad/79e697.wgsl.expected.spvasm b/test/tint/builtins/gen/textureLoad/79e697.wgsl.expected.spvasm index 9ea6971c4e..a49c40cb50 100644 --- a/test/tint/builtins/gen/textureLoad/79e697.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureLoad/79e697.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 41 +; Bound: 42 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -42,37 +42,38 @@ %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %23 = OpConstantComposite %v3int %int_0 %int_0 %int_1 + %24 = OpConstantNull %int %_ptr_Function_v4int = OpTypePointer Function %v4int - %26 = OpConstantNull %v4int - %27 = OpTypeFunction %v4float + %27 = OpConstantNull %v4int + %28 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %textureLoad_79e697 = OpFunction %void None %13 %16 = OpLabel - %res = OpVariable %_ptr_Function_v4int Function %26 + %res = OpVariable %_ptr_Function_v4int Function %27 %19 = OpLoad %11 %arg_0 - %17 = OpImageFetch %v4int %19 %23 Lod %int_0 + %17 = OpImageFetch %v4int %19 %23 Lod %24 OpStore %res %17 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %27 - %29 = OpLabel - %30 = OpFunctionCall %void %textureLoad_79e697 +%vertex_main_inner = OpFunction %v4float None %28 + %30 = OpLabel + %31 = OpFunctionCall %void %textureLoad_79e697 OpReturnValue %5 OpFunctionEnd %vertex_main = OpFunction %void None %13 - %32 = OpLabel - %33 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %33 + %33 = OpLabel + %34 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %34 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd %fragment_main = OpFunction %void None %13 - %36 = OpLabel - %37 = OpFunctionCall %void %textureLoad_79e697 + %37 = OpLabel + %38 = OpFunctionCall %void %textureLoad_79e697 OpReturn OpFunctionEnd %compute_main = OpFunction %void None %13 - %39 = OpLabel - %40 = OpFunctionCall %void %textureLoad_79e697 + %40 = OpLabel + %41 = OpFunctionCall %void %textureLoad_79e697 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureLoad/7c90e5.wgsl.expected.spvasm b/test/tint/builtins/gen/textureLoad/7c90e5.wgsl.expected.spvasm index 72245acf47..8c03bfbce6 100644 --- a/test/tint/builtins/gen/textureLoad/7c90e5.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureLoad/7c90e5.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 42 +; Bound: 43 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -43,37 +43,38 @@ %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %24 = OpConstantComposite %v3int %int_0 %int_0 %int_1 + %25 = OpConstantNull %int %_ptr_Function_v4uint = OpTypePointer Function %v4uint - %27 = OpConstantNull %v4uint - %28 = OpTypeFunction %v4float + %28 = OpConstantNull %v4uint + %29 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %textureLoad_7c90e5 = OpFunction %void None %13 %16 = OpLabel - %res = OpVariable %_ptr_Function_v4uint Function %27 + %res = OpVariable %_ptr_Function_v4uint Function %28 %19 = OpLoad %11 %arg_0 - %17 = OpImageFetch %v4uint %19 %24 Lod %int_0 + %17 = OpImageFetch %v4uint %19 %24 Lod %25 OpStore %res %17 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %28 - %30 = OpLabel - %31 = OpFunctionCall %void %textureLoad_7c90e5 +%vertex_main_inner = OpFunction %v4float None %29 + %31 = OpLabel + %32 = OpFunctionCall %void %textureLoad_7c90e5 OpReturnValue %5 OpFunctionEnd %vertex_main = OpFunction %void None %13 - %33 = OpLabel - %34 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %34 + %34 = OpLabel + %35 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %35 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd %fragment_main = OpFunction %void None %13 - %37 = OpLabel - %38 = OpFunctionCall %void %textureLoad_7c90e5 + %38 = OpLabel + %39 = OpFunctionCall %void %textureLoad_7c90e5 OpReturn OpFunctionEnd %compute_main = OpFunction %void None %13 - %40 = OpLabel - %41 = OpFunctionCall %void %textureLoad_7c90e5 + %41 = OpLabel + %42 = OpFunctionCall %void %textureLoad_7c90e5 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureLoad/81c381.wgsl.expected.spvasm b/test/tint/builtins/gen/textureLoad/81c381.wgsl.expected.spvasm index 87aa1c5ce9..fc25c50c00 100644 --- a/test/tint/builtins/gen/textureLoad/81c381.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureLoad/81c381.wgsl.expected.spvasm @@ -39,7 +39,7 @@ %12 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 - %int_0 = OpConstant %int 0 + %20 = OpConstantNull %int %_ptr_Function_v4float = OpTypePointer Function %v4float %23 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 @@ -47,7 +47,7 @@ %15 = OpLabel %res = OpVariable %_ptr_Function_v4float Function %5 %17 = OpLoad %11 %arg_0 - %16 = OpImageFetch %v4float %17 %int_1 Lod %int_0 + %16 = OpImageFetch %v4float %17 %int_1 Lod %20 OpStore %res %16 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureLoad/87be85.wgsl.expected.spvasm b/test/tint/builtins/gen/textureLoad/87be85.wgsl.expected.spvasm index c8c2895822..ed87e170fe 100644 --- a/test/tint/builtins/gen/textureLoad/87be85.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureLoad/87be85.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 39 +; Bound: 40 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -41,36 +41,37 @@ %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %22 = OpConstantComposite %v3int %int_0 %int_0 %int_1 + %23 = OpConstantNull %int %_ptr_Function_v4float = OpTypePointer Function %v4float - %25 = OpTypeFunction %v4float + %26 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %textureLoad_87be85 = OpFunction %void None %12 %15 = OpLabel %res = OpVariable %_ptr_Function_v4float Function %5 %17 = OpLoad %11 %arg_0 - %16 = OpImageFetch %v4float %17 %22 Lod %int_0 + %16 = OpImageFetch %v4float %17 %22 Lod %23 OpStore %res %16 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %25 - %27 = OpLabel - %28 = OpFunctionCall %void %textureLoad_87be85 +%vertex_main_inner = OpFunction %v4float None %26 + %28 = OpLabel + %29 = OpFunctionCall %void %textureLoad_87be85 OpReturnValue %5 OpFunctionEnd %vertex_main = OpFunction %void None %12 - %30 = OpLabel - %31 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %31 + %31 = OpLabel + %32 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %32 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd %fragment_main = OpFunction %void None %12 - %34 = OpLabel - %35 = OpFunctionCall %void %textureLoad_87be85 + %35 = OpLabel + %36 = OpFunctionCall %void %textureLoad_87be85 OpReturn OpFunctionEnd %compute_main = OpFunction %void None %12 - %37 = OpLabel - %38 = OpFunctionCall %void %textureLoad_87be85 + %38 = OpLabel + %39 = OpFunctionCall %void %textureLoad_87be85 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureLoad/8acf41.wgsl.expected.spvasm b/test/tint/builtins/gen/textureLoad/8acf41.wgsl.expected.spvasm index 950b97350a..7fe7f876b9 100644 --- a/test/tint/builtins/gen/textureLoad/8acf41.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureLoad/8acf41.wgsl.expected.spvasm @@ -102,7 +102,7 @@ %v2int = OpTypeVector %int 2 %61 = OpTypeFunction %v4float %11 %11 %v2int %ExternalTextureParams %uint_1 = OpConstant %uint 1 - %int_0 = OpConstant %int 0 + %78 = OpConstantNull %int %v2float = OpTypeVector %float 2 %float_1 = OpConstant %float 1 %void = OpTypeVoid @@ -158,14 +158,14 @@ OpSelectionMerge %74 None OpBranchConditional %73 %75 %76 %75 = OpLabel - %77 = OpImageFetch %v4float %plane0 %coord Lod %int_0 + %77 = OpImageFetch %v4float %plane0 %coord Lod %78 %79 = OpVectorShuffle %v3float %77 %77 0 1 2 OpStore %color %79 OpBranch %74 %76 = OpLabel - %80 = OpImageFetch %v4float %plane0 %coord Lod %int_0 + %80 = OpImageFetch %v4float %plane0 %coord Lod %78 %81 = OpCompositeExtract %float %80 0 - %82 = OpImageFetch %v4float %plane1 %coord Lod %int_0 + %82 = OpImageFetch %v4float %plane1 %coord Lod %78 %84 = OpVectorShuffle %v2float %82 %82 0 1 %85 = OpCompositeExtract %float %84 0 %86 = OpCompositeExtract %float %84 1 diff --git a/test/tint/builtins/gen/textureLoad/9b2667.wgsl.expected.spvasm b/test/tint/builtins/gen/textureLoad/9b2667.wgsl.expected.spvasm index 891f9a441f..50cf52d3a7 100644 --- a/test/tint/builtins/gen/textureLoad/9b2667.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureLoad/9b2667.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 40 +; Bound: 41 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -41,37 +41,38 @@ %int_0 = OpConstant %int 0 %int_1 = OpConstant %int 1 %23 = OpConstantComposite %v3int %int_0 %int_0 %int_1 + %24 = OpConstantNull %int %_ptr_Function_float = OpTypePointer Function %float - %26 = OpTypeFunction %v4float + %27 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 %textureLoad_9b2667 = OpFunction %void None %12 %15 = OpLabel %res = OpVariable %_ptr_Function_float Function %8 %18 = OpLoad %11 %arg_0 - %17 = OpImageFetch %v4float %18 %23 Lod %int_0 + %17 = OpImageFetch %v4float %18 %23 Lod %24 %16 = OpCompositeExtract %float %17 0 OpStore %res %16 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %26 - %28 = OpLabel - %29 = OpFunctionCall %void %textureLoad_9b2667 +%vertex_main_inner = OpFunction %v4float None %27 + %29 = OpLabel + %30 = OpFunctionCall %void %textureLoad_9b2667 OpReturnValue %5 OpFunctionEnd %vertex_main = OpFunction %void None %12 - %31 = OpLabel - %32 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %32 + %32 = OpLabel + %33 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %33 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd %fragment_main = OpFunction %void None %12 - %35 = OpLabel - %36 = OpFunctionCall %void %textureLoad_9b2667 + %36 = OpLabel + %37 = OpFunctionCall %void %textureLoad_9b2667 OpReturn OpFunctionEnd %compute_main = OpFunction %void None %12 - %38 = OpLabel - %39 = OpFunctionCall %void %textureLoad_9b2667 + %39 = OpLabel + %40 = OpFunctionCall %void %textureLoad_9b2667 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureLoad/a9a9f5.wgsl.expected.spvasm b/test/tint/builtins/gen/textureLoad/a9a9f5.wgsl.expected.spvasm index f9c5c1f7e7..525affc692 100644 --- a/test/tint/builtins/gen/textureLoad/a9a9f5.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureLoad/a9a9f5.wgsl.expected.spvasm @@ -41,7 +41,7 @@ %int = OpTypeInt 32 1 %v3int = OpTypeVector %int 3 %22 = OpConstantNull %v3int - %int_0 = OpConstant %int 0 + %23 = OpConstantNull %int %_ptr_Function_v4uint = OpTypePointer Function %v4uint %26 = OpConstantNull %v4uint %27 = OpTypeFunction %v4float @@ -50,7 +50,7 @@ %16 = OpLabel %res = OpVariable %_ptr_Function_v4uint Function %26 %19 = OpLoad %11 %arg_0 - %17 = OpImageFetch %v4uint %19 %22 Lod %int_0 + %17 = OpImageFetch %v4uint %19 %22 Lod %23 OpStore %res %17 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureLoad/c2a480.wgsl.expected.spvasm b/test/tint/builtins/gen/textureLoad/c2a480.wgsl.expected.spvasm index 2a12e214cf..3f506a5367 100644 --- a/test/tint/builtins/gen/textureLoad/c2a480.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureLoad/c2a480.wgsl.expected.spvasm @@ -40,7 +40,7 @@ %v4int = OpTypeVector %int 4 %v2int = OpTypeVector %int 2 %21 = OpConstantNull %v2int - %int_0 = OpConstant %int 0 + %22 = OpConstantNull %int %_ptr_Function_v4int = OpTypePointer Function %v4int %25 = OpConstantNull %v4int %26 = OpTypeFunction %v4float @@ -49,7 +49,7 @@ %16 = OpLabel %res = OpVariable %_ptr_Function_v4int Function %25 %19 = OpLoad %11 %arg_0 - %17 = OpImageFetch %v4int %19 %21 Lod %int_0 + %17 = OpImageFetch %v4int %19 %21 Lod %22 OpStore %res %17 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureSampleLevel/02be59.wgsl.expected.spvasm b/test/tint/builtins/gen/textureSampleLevel/02be59.wgsl.expected.spvasm index 9a116965fc..3b46a822bb 100644 --- a/test/tint/builtins/gen/textureSampleLevel/02be59.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureSampleLevel/02be59.wgsl.expected.spvasm @@ -46,7 +46,7 @@ %v2float = OpTypeVector %float 2 %26 = OpConstantNull %v2float %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %29 = OpConstantNull %int %_ptr_Function_float = OpTypePointer Function %float %32 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 @@ -56,7 +56,7 @@ %21 = OpLoad %14 %arg_1 %22 = OpLoad %11 %arg_0 %24 = OpSampledImage %23 %22 %21 - %27 = OpConvertSToF %float %int_0 + %27 = OpConvertSToF %float %29 %20 = OpImageSampleExplicitLod %v4float %24 %26 Lod %27 %19 = OpCompositeExtract %float %20 0 OpStore %res %19 diff --git a/test/tint/builtins/gen/textureSampleLevel/1b0291.wgsl.expected.spvasm b/test/tint/builtins/gen/textureSampleLevel/1b0291.wgsl.expected.spvasm index fe52162d4f..cd488f86f3 100644 --- a/test/tint/builtins/gen/textureSampleLevel/1b0291.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureSampleLevel/1b0291.wgsl.expected.spvasm @@ -46,7 +46,7 @@ %v3float = OpTypeVector %float 3 %26 = OpConstantNull %v3float %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %29 = OpConstantNull %int %_ptr_Function_float = OpTypePointer Function %float %32 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 @@ -56,7 +56,7 @@ %21 = OpLoad %14 %arg_1 %22 = OpLoad %11 %arg_0 %24 = OpSampledImage %23 %22 %21 - %27 = OpConvertSToF %float %int_0 + %27 = OpConvertSToF %float %29 %20 = OpImageSampleExplicitLod %v4float %24 %26 Lod %27 %19 = OpCompositeExtract %float %20 0 OpStore %res %19 diff --git a/test/tint/builtins/gen/textureSampleLevel/1bf73e.wgsl.expected.spvasm b/test/tint/builtins/gen/textureSampleLevel/1bf73e.wgsl.expected.spvasm index 28e22104ce..00355c9d57 100644 --- a/test/tint/builtins/gen/textureSampleLevel/1bf73e.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureSampleLevel/1bf73e.wgsl.expected.spvasm @@ -47,7 +47,7 @@ %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 - %int_0 = OpConstant %int 0 + %32 = OpConstantNull %int %_ptr_Function_float = OpTypePointer Function %float %35 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 @@ -59,7 +59,7 @@ %24 = OpSampledImage %23 %22 %21 %27 = OpConvertSToF %float %int_1 %30 = OpCompositeConstruct %v3float %float_0 %float_0 %27 - %31 = OpConvertSToF %float %int_0 + %31 = OpConvertSToF %float %32 %20 = OpImageSampleExplicitLod %v4float %24 %30 Lod %31 %19 = OpCompositeExtract %float %20 0 OpStore %res %19 diff --git a/test/tint/builtins/gen/textureSampleLevel/47daa4.wgsl.expected.spvasm b/test/tint/builtins/gen/textureSampleLevel/47daa4.wgsl.expected.spvasm index e46c365d1e..6ec86741da 100644 --- a/test/tint/builtins/gen/textureSampleLevel/47daa4.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureSampleLevel/47daa4.wgsl.expected.spvasm @@ -46,7 +46,7 @@ %v2float = OpTypeVector %float 2 %26 = OpConstantNull %v2float %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %29 = OpConstantNull %int %v2int = OpTypeVector %int 2 %31 = OpConstantNull %v2int %_ptr_Function_float = OpTypePointer Function %float @@ -58,7 +58,7 @@ %21 = OpLoad %14 %arg_1 %22 = OpLoad %11 %arg_0 %24 = OpSampledImage %23 %22 %21 - %27 = OpConvertSToF %float %int_0 + %27 = OpConvertSToF %float %29 %20 = OpImageSampleExplicitLod %v4float %24 %26 Lod|ConstOffset %27 %31 %19 = OpCompositeExtract %float %20 0 OpStore %res %19 diff --git a/test/tint/builtins/gen/textureSampleLevel/979816.wgsl.expected.spvasm b/test/tint/builtins/gen/textureSampleLevel/979816.wgsl.expected.spvasm index ebf64411fe..ab657b06d7 100644 --- a/test/tint/builtins/gen/textureSampleLevel/979816.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureSampleLevel/979816.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 136 +; Bound: 135 ; Schema: 0 OpCapability Shader %30 = OpExtInstImport "GLSL.std.450" @@ -109,13 +109,12 @@ %64 = OpTypeFunction %v4float %11 %11 %23 %v2float %ExternalTextureParams %uint_1 = OpConstant %uint 1 %81 = OpTypeSampledImage %11 - %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %void = OpTypeVoid - %111 = OpTypeFunction %void - %119 = OpConstantNull %v2float + %110 = OpTypeFunction %void + %118 = OpConstantNull %v2float %_ptr_Function_v4float = OpTypePointer Function %v4float - %123 = OpTypeFunction %v4float + %122 = OpTypeFunction %v4float %gammaCorrection = OpFunction %v3float None %24 %v = OpFunctionParameter %v3float %params = OpFunctionParameter %GammaTransferParams @@ -166,74 +165,74 @@ OpBranchConditional %76 %78 %79 %78 = OpLabel %82 = OpSampledImage %81 %plane0 %smp - %80 = OpImageSampleExplicitLod %v4float %82 %coord Lod %float_0 - %84 = OpVectorShuffle %v3float %80 %80 0 1 2 - OpStore %color %84 + %80 = OpImageSampleExplicitLod %v4float %82 %coord Lod %8 + %83 = OpVectorShuffle %v3float %80 %80 0 1 2 + OpStore %color %83 OpBranch %77 %79 = OpLabel - %86 = OpSampledImage %81 %plane0 %smp - %85 = OpImageSampleExplicitLod %v4float %86 %coord Lod %float_0 - %87 = OpCompositeExtract %float %85 0 - %89 = OpSampledImage %81 %plane1 %smp - %88 = OpImageSampleExplicitLod %v4float %89 %coord Lod %float_0 - %90 = OpVectorShuffle %v2float %88 %88 0 1 - %91 = OpCompositeExtract %float %90 0 - %92 = OpCompositeExtract %float %90 1 - %94 = OpCompositeConstruct %v4float %87 %91 %92 %float_1 - %95 = OpCompositeExtract %mat3v4float %params_0 1 - %96 = OpVectorTimesMatrix %v3float %94 %95 - OpStore %color %96 + %85 = OpSampledImage %81 %plane0 %smp + %84 = OpImageSampleExplicitLod %v4float %85 %coord Lod %8 + %86 = OpCompositeExtract %float %84 0 + %88 = OpSampledImage %81 %plane1 %smp + %87 = OpImageSampleExplicitLod %v4float %88 %coord Lod %8 + %89 = OpVectorShuffle %v2float %87 %87 0 1 + %90 = OpCompositeExtract %float %89 0 + %91 = OpCompositeExtract %float %89 1 + %93 = OpCompositeConstruct %v4float %86 %90 %91 %float_1 + %94 = OpCompositeExtract %mat3v4float %params_0 1 + %95 = OpVectorTimesMatrix %v3float %93 %94 + OpStore %color %95 OpBranch %77 %77 = OpLabel - %98 = OpLoad %v3float %color - %99 = OpCompositeExtract %GammaTransferParams %params_0 2 - %97 = OpFunctionCall %v3float %gammaCorrection %98 %99 - OpStore %color %97 - %100 = OpCompositeExtract %mat3v3float %params_0 4 - %101 = OpLoad %v3float %color - %102 = OpMatrixTimesVector %v3float %100 %101 + %97 = OpLoad %v3float %color + %98 = OpCompositeExtract %GammaTransferParams %params_0 2 + %96 = OpFunctionCall %v3float %gammaCorrection %97 %98 + OpStore %color %96 + %99 = OpCompositeExtract %mat3v3float %params_0 4 + %100 = OpLoad %v3float %color + %101 = OpMatrixTimesVector %v3float %99 %100 + OpStore %color %101 + %103 = OpLoad %v3float %color + %104 = OpCompositeExtract %GammaTransferParams %params_0 3 + %102 = OpFunctionCall %v3float %gammaCorrection %103 %104 OpStore %color %102 - %104 = OpLoad %v3float %color - %105 = OpCompositeExtract %GammaTransferParams %params_0 3 - %103 = OpFunctionCall %v3float %gammaCorrection %104 %105 - OpStore %color %103 - %106 = OpLoad %v3float %color - %107 = OpCompositeExtract %float %106 0 - %108 = OpCompositeExtract %float %106 1 - %109 = OpCompositeExtract %float %106 2 - %110 = OpCompositeConstruct %v4float %107 %108 %109 %float_1 - OpReturnValue %110 + %105 = OpLoad %v3float %color + %106 = OpCompositeExtract %float %105 0 + %107 = OpCompositeExtract %float %105 1 + %108 = OpCompositeExtract %float %105 2 + %109 = OpCompositeConstruct %v4float %106 %107 %108 %float_1 + OpReturnValue %109 OpFunctionEnd -%textureSampleLevel_979816 = OpFunction %void None %111 - %114 = OpLabel +%textureSampleLevel_979816 = OpFunction %void None %110 + %113 = OpLabel %res = OpVariable %_ptr_Function_v4float Function %5 - %116 = OpLoad %11 %arg_0 - %117 = OpLoad %11 %ext_tex_plane_1 - %118 = OpLoad %23 %arg_1 - %120 = OpLoad %ExternalTextureParams %ext_tex_params - %115 = OpFunctionCall %v4float %textureSampleExternal %116 %117 %118 %119 %120 - OpStore %res %115 + %115 = OpLoad %11 %arg_0 + %116 = OpLoad %11 %ext_tex_plane_1 + %117 = OpLoad %23 %arg_1 + %119 = OpLoad %ExternalTextureParams %ext_tex_params + %114 = OpFunctionCall %v4float %textureSampleExternal %115 %116 %117 %118 %119 + OpStore %res %114 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %v4float None %123 - %125 = OpLabel - %126 = OpFunctionCall %void %textureSampleLevel_979816 +%vertex_main_inner = OpFunction %v4float None %122 + %124 = OpLabel + %125 = OpFunctionCall %void %textureSampleLevel_979816 OpReturnValue %5 OpFunctionEnd -%vertex_main = OpFunction %void None %111 - %128 = OpLabel - %129 = OpFunctionCall %v4float %vertex_main_inner - OpStore %value %129 +%vertex_main = OpFunction %void None %110 + %127 = OpLabel + %128 = OpFunctionCall %v4float %vertex_main_inner + OpStore %value %128 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%fragment_main = OpFunction %void None %111 - %131 = OpLabel - %132 = OpFunctionCall %void %textureSampleLevel_979816 +%fragment_main = OpFunction %void None %110 + %130 = OpLabel + %131 = OpFunctionCall %void %textureSampleLevel_979816 OpReturn OpFunctionEnd -%compute_main = OpFunction %void None %111 - %134 = OpLabel - %135 = OpFunctionCall %void %textureSampleLevel_979816 +%compute_main = OpFunction %void None %110 + %133 = OpLabel + %134 = OpFunctionCall %void %textureSampleLevel_979816 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/gen/textureSampleLevel/ae5e39.wgsl.expected.spvasm b/test/tint/builtins/gen/textureSampleLevel/ae5e39.wgsl.expected.spvasm index 550cf30e16..460f8a25ec 100644 --- a/test/tint/builtins/gen/textureSampleLevel/ae5e39.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureSampleLevel/ae5e39.wgsl.expected.spvasm @@ -47,7 +47,7 @@ %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 - %int_0 = OpConstant %int 0 + %31 = OpConstantNull %int %_ptr_Function_float = OpTypePointer Function %float %34 = OpTypeFunction %v4float %float_1 = OpConstant %float 1 @@ -59,7 +59,7 @@ %24 = OpSampledImage %23 %22 %21 %26 = OpConvertSToF %float %int_1 %29 = OpCompositeConstruct %v4float %float_0 %float_0 %float_0 %26 - %30 = OpConvertSToF %float %int_0 + %30 = OpConvertSToF %float %31 %20 = OpImageSampleExplicitLod %v4float %24 %29 Lod %30 %19 = OpCompositeExtract %float %20 0 OpStore %res %19 diff --git a/test/tint/builtins/gen/textureSampleLevel/ba93b3.wgsl.expected.spvasm b/test/tint/builtins/gen/textureSampleLevel/ba93b3.wgsl.expected.spvasm index 043c7ba194..4737eca809 100644 --- a/test/tint/builtins/gen/textureSampleLevel/ba93b3.wgsl.expected.spvasm +++ b/test/tint/builtins/gen/textureSampleLevel/ba93b3.wgsl.expected.spvasm @@ -47,7 +47,7 @@ %float_0 = OpConstant %float 0 %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 - %int_0 = OpConstant %int 0 + %32 = OpConstantNull %int %v2int = OpTypeVector %int 2 %34 = OpConstantNull %v2int %_ptr_Function_float = OpTypePointer Function %float @@ -61,7 +61,7 @@ %24 = OpSampledImage %23 %22 %21 %27 = OpConvertSToF %float %int_1 %30 = OpCompositeConstruct %v3float %float_0 %float_0 %27 - %31 = OpConvertSToF %float %int_0 + %31 = OpConvertSToF %float %32 %20 = OpImageSampleExplicitLod %v4float %24 %30 Lod|ConstOffset %31 %34 %19 = OpCompositeExtract %float %20 0 OpStore %res %19 diff --git a/test/tint/builtins/insertBits/scalar/i32.spvasm.expected.spvasm b/test/tint/builtins/insertBits/scalar/i32.spvasm.expected.spvasm index b8aa1b6a60..637e76d438 100644 --- a/test/tint/builtins/insertBits/scalar/i32.spvasm.expected.spvasm +++ b/test/tint/builtins/insertBits/scalar/i32.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 39 +; Bound: 37 ; Schema: 0 OpCapability Shader %11 = OpExtInstImport "GLSL.std.450" @@ -25,12 +25,10 @@ %uint_32 = OpConstant %uint 32 %void = OpTypeVoid %17 = OpTypeFunction %void - %int_0 = OpConstant %int 0 + %21 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %24 = OpConstantNull %int - %uint_0 = OpConstant %uint 0 + %25 = OpConstantNull %uint %_ptr_Function_uint = OpTypePointer Function %uint - %29 = OpConstantNull %uint %tint_insert_bits = OpFunction %int None %1 %v = OpFunctionParameter %int %n = OpFunctionParameter %int @@ -46,23 +44,23 @@ OpFunctionEnd %f_1 = OpFunction %void None %17 %20 = OpLabel - %v_0 = OpVariable %_ptr_Function_int Function %24 - %n_0 = OpVariable %_ptr_Function_int Function %24 - %offset_1 = OpVariable %_ptr_Function_uint Function %29 - %count_0 = OpVariable %_ptr_Function_uint Function %29 - OpStore %v_0 %int_0 - OpStore %n_0 %int_0 - OpStore %offset_1 %uint_0 - OpStore %count_0 %uint_0 - %31 = OpLoad %int %v_0 - %32 = OpLoad %int %n_0 - %33 = OpLoad %uint %offset_1 - %34 = OpLoad %uint %count_0 - %35 = OpFunctionCall %int %tint_insert_bits %31 %32 %33 %34 + %v_0 = OpVariable %_ptr_Function_int Function %21 + %n_0 = OpVariable %_ptr_Function_int Function %21 + %offset_1 = OpVariable %_ptr_Function_uint Function %25 + %count_0 = OpVariable %_ptr_Function_uint Function %25 + OpStore %v_0 %21 + OpStore %n_0 %21 + OpStore %offset_1 %25 + OpStore %count_0 %25 + %29 = OpLoad %int %v_0 + %30 = OpLoad %int %n_0 + %31 = OpLoad %uint %offset_1 + %32 = OpLoad %uint %count_0 + %33 = OpFunctionCall %int %tint_insert_bits %29 %30 %31 %32 OpReturn OpFunctionEnd %f = OpFunction %void None %17 - %37 = OpLabel - %38 = OpFunctionCall %void %f_1 + %35 = OpLabel + %36 = OpFunctionCall %void %f_1 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/insertBits/scalar/u32.spvasm.expected.spvasm b/test/tint/builtins/insertBits/scalar/u32.spvasm.expected.spvasm index a44f9da469..843fb94aff 100644 --- a/test/tint/builtins/insertBits/scalar/u32.spvasm.expected.spvasm +++ b/test/tint/builtins/insertBits/scalar/u32.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 35 +; Bound: 34 ; Schema: 0 OpCapability Shader %10 = OpExtInstImport "GLSL.std.450" @@ -24,9 +24,8 @@ %uint_32 = OpConstant %uint 32 %void = OpTypeVoid %16 = OpTypeFunction %void - %uint_0 = OpConstant %uint 0 + %20 = OpConstantNull %uint %_ptr_Function_uint = OpTypePointer Function %uint - %23 = OpConstantNull %uint %tint_insert_bits = OpFunction %uint None %1 %v = OpFunctionParameter %uint %n = OpFunctionParameter %uint @@ -42,23 +41,23 @@ OpFunctionEnd %f_1 = OpFunction %void None %16 %19 = OpLabel - %v_0 = OpVariable %_ptr_Function_uint Function %23 - %n_0 = OpVariable %_ptr_Function_uint Function %23 - %offset_1 = OpVariable %_ptr_Function_uint Function %23 - %count_0 = OpVariable %_ptr_Function_uint Function %23 - OpStore %v_0 %uint_0 - OpStore %n_0 %uint_0 - OpStore %offset_1 %uint_0 - OpStore %count_0 %uint_0 - %27 = OpLoad %uint %v_0 - %28 = OpLoad %uint %n_0 - %29 = OpLoad %uint %offset_1 - %30 = OpLoad %uint %count_0 - %31 = OpFunctionCall %uint %tint_insert_bits %27 %28 %29 %30 + %v_0 = OpVariable %_ptr_Function_uint Function %20 + %n_0 = OpVariable %_ptr_Function_uint Function %20 + %offset_1 = OpVariable %_ptr_Function_uint Function %20 + %count_0 = OpVariable %_ptr_Function_uint Function %20 + OpStore %v_0 %20 + OpStore %n_0 %20 + OpStore %offset_1 %20 + OpStore %count_0 %20 + %26 = OpLoad %uint %v_0 + %27 = OpLoad %uint %n_0 + %28 = OpLoad %uint %offset_1 + %29 = OpLoad %uint %count_0 + %30 = OpFunctionCall %uint %tint_insert_bits %26 %27 %28 %29 OpReturn OpFunctionEnd %f = OpFunction %void None %16 - %33 = OpLabel - %34 = OpFunctionCall %void %f_1 + %32 = OpLabel + %33 = OpFunctionCall %void %f_1 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/insertBits/vec3/i32.spvasm.expected.spvasm b/test/tint/builtins/insertBits/vec3/i32.spvasm.expected.spvasm index b595d27b70..9681d0162c 100644 --- a/test/tint/builtins/insertBits/vec3/i32.spvasm.expected.spvasm +++ b/test/tint/builtins/insertBits/vec3/i32.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 39 +; Bound: 38 ; Schema: 0 OpCapability Shader %12 = OpExtInstImport "GLSL.std.450" @@ -28,9 +28,8 @@ %18 = OpTypeFunction %void %22 = OpConstantNull %v3int %_ptr_Function_v3int = OpTypePointer Function %v3int - %uint_0 = OpConstant %uint 0 + %26 = OpConstantNull %uint %_ptr_Function_uint = OpTypePointer Function %uint - %29 = OpConstantNull %uint %tint_insert_bits = OpFunction %v3int None %1 %v = OpFunctionParameter %v3int %n = OpFunctionParameter %v3int @@ -48,21 +47,21 @@ %21 = OpLabel %v_0 = OpVariable %_ptr_Function_v3int Function %22 %n_0 = OpVariable %_ptr_Function_v3int Function %22 - %offset_1 = OpVariable %_ptr_Function_uint Function %29 - %count_0 = OpVariable %_ptr_Function_uint Function %29 + %offset_1 = OpVariable %_ptr_Function_uint Function %26 + %count_0 = OpVariable %_ptr_Function_uint Function %26 OpStore %v_0 %22 OpStore %n_0 %22 - OpStore %offset_1 %uint_0 - OpStore %count_0 %uint_0 - %31 = OpLoad %v3int %v_0 - %32 = OpLoad %v3int %n_0 - %33 = OpLoad %uint %offset_1 - %34 = OpLoad %uint %count_0 - %35 = OpFunctionCall %v3int %tint_insert_bits %31 %32 %33 %34 + OpStore %offset_1 %26 + OpStore %count_0 %26 + %30 = OpLoad %v3int %v_0 + %31 = OpLoad %v3int %n_0 + %32 = OpLoad %uint %offset_1 + %33 = OpLoad %uint %count_0 + %34 = OpFunctionCall %v3int %tint_insert_bits %30 %31 %32 %33 OpReturn OpFunctionEnd %f = OpFunction %void None %18 - %37 = OpLabel - %38 = OpFunctionCall %void %f_1 + %36 = OpLabel + %37 = OpFunctionCall %void %f_1 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/insertBits/vec3/u32.spvasm.expected.spvasm b/test/tint/builtins/insertBits/vec3/u32.spvasm.expected.spvasm index 688e14073c..b60baaf771 100644 --- a/test/tint/builtins/insertBits/vec3/u32.spvasm.expected.spvasm +++ b/test/tint/builtins/insertBits/vec3/u32.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 38 +; Bound: 37 ; Schema: 0 OpCapability Shader %11 = OpExtInstImport "GLSL.std.450" @@ -27,9 +27,8 @@ %17 = OpTypeFunction %void %21 = OpConstantNull %v3uint %_ptr_Function_v3uint = OpTypePointer Function %v3uint - %uint_0 = OpConstant %uint 0 + %25 = OpConstantNull %uint %_ptr_Function_uint = OpTypePointer Function %uint - %28 = OpConstantNull %uint %tint_insert_bits = OpFunction %v3uint None %1 %v = OpFunctionParameter %v3uint %n = OpFunctionParameter %v3uint @@ -47,21 +46,21 @@ %20 = OpLabel %v_0 = OpVariable %_ptr_Function_v3uint Function %21 %n_0 = OpVariable %_ptr_Function_v3uint Function %21 - %offset_1 = OpVariable %_ptr_Function_uint Function %28 - %count_0 = OpVariable %_ptr_Function_uint Function %28 + %offset_1 = OpVariable %_ptr_Function_uint Function %25 + %count_0 = OpVariable %_ptr_Function_uint Function %25 OpStore %v_0 %21 OpStore %n_0 %21 - OpStore %offset_1 %uint_0 - OpStore %count_0 %uint_0 - %30 = OpLoad %v3uint %v_0 - %31 = OpLoad %v3uint %n_0 - %32 = OpLoad %uint %offset_1 - %33 = OpLoad %uint %count_0 - %34 = OpFunctionCall %v3uint %tint_insert_bits %30 %31 %32 %33 + OpStore %offset_1 %25 + OpStore %count_0 %25 + %29 = OpLoad %v3uint %v_0 + %30 = OpLoad %v3uint %n_0 + %31 = OpLoad %uint %offset_1 + %32 = OpLoad %uint %count_0 + %33 = OpFunctionCall %v3uint %tint_insert_bits %29 %30 %31 %32 OpReturn OpFunctionEnd %f = OpFunction %void None %17 - %36 = OpLabel - %37 = OpFunctionCall %void %f_1 + %35 = OpLabel + %36 = OpFunctionCall %void %f_1 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/textureGather/f32/red.wgsl.expected.spvasm b/test/tint/builtins/textureGather/f32/red.wgsl.expected.spvasm index 6baa49c22d..23c3071c72 100644 --- a/test/tint/builtins/textureGather/f32/red.wgsl.expected.spvasm +++ b/test/tint/builtins/textureGather/f32/red.wgsl.expected.spvasm @@ -29,7 +29,7 @@ %v2float = OpTypeVector %float 2 %19 = OpConstantNull %v2float %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %21 = OpConstantNull %int %_ptr_Function_v4float = OpTypePointer Function %v4float %24 = OpConstantNull %v4float %main = OpFunction %void None %8 @@ -38,7 +38,7 @@ %14 = OpLoad %7 %s %15 = OpLoad %3 %t %17 = OpSampledImage %16 %15 %14 - %12 = OpImageGather %v4float %17 %19 %int_0 + %12 = OpImageGather %v4float %17 %19 %21 OpStore %res %12 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/textureGather/i32/red.wgsl.expected.spvasm b/test/tint/builtins/textureGather/i32/red.wgsl.expected.spvasm index 2a619fa1a5..712859a3b0 100644 --- a/test/tint/builtins/textureGather/i32/red.wgsl.expected.spvasm +++ b/test/tint/builtins/textureGather/i32/red.wgsl.expected.spvasm @@ -29,7 +29,7 @@ %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 %20 = OpConstantNull %v2float - %int_0 = OpConstant %int 0 + %21 = OpConstantNull %int %_ptr_Function_v4int = OpTypePointer Function %v4int %24 = OpConstantNull %v4int %main = OpFunction %void None %8 @@ -38,7 +38,7 @@ %14 = OpLoad %7 %s %15 = OpLoad %3 %t %17 = OpSampledImage %16 %15 %14 - %12 = OpImageGather %v4int %17 %20 %int_0 + %12 = OpImageGather %v4int %17 %20 %21 OpStore %res %12 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/textureGather/u32/red.wgsl.expected.spvasm b/test/tint/builtins/textureGather/u32/red.wgsl.expected.spvasm index 8c52b9ce3a..63693d6b2b 100644 --- a/test/tint/builtins/textureGather/u32/red.wgsl.expected.spvasm +++ b/test/tint/builtins/textureGather/u32/red.wgsl.expected.spvasm @@ -30,7 +30,7 @@ %v2float = OpTypeVector %float 2 %20 = OpConstantNull %v2float %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %22 = OpConstantNull %int %_ptr_Function_v4uint = OpTypePointer Function %v4uint %25 = OpConstantNull %v4uint %main = OpFunction %void None %8 @@ -39,7 +39,7 @@ %14 = OpLoad %7 %s %15 = OpLoad %3 %t %17 = OpSampledImage %16 %15 %14 - %12 = OpImageGather %v4uint %17 %20 %int_0 + %12 = OpImageGather %v4uint %17 %20 %22 OpStore %res %12 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/textureLoad/depth_ms.spvasm.expected.spvasm b/test/tint/builtins/textureLoad/depth_ms.spvasm.expected.spvasm index ffa937e53b..b6a920161d 100644 --- a/test/tint/builtins/textureLoad/depth_ms.spvasm.expected.spvasm +++ b/test/tint/builtins/textureLoad/depth_ms.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 62 +; Bound: 61 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -47,72 +47,71 @@ %tint_symbol_1 = OpVariable %_ptr_Private_v4float Private %5 %void = OpTypeVoid %14 = OpTypeFunction %void - %float_0 = OpConstant %float 0 %_ptr_Function_float = OpTypePointer Function %float %int = OpTypeInt 32 1 %v2int = OpTypeVector %int 2 - %26 = OpConstantNull %v2int + %25 = OpConstantNull %v2int %int_1 = OpConstant %int 1 - %30 = OpTypeFunction %void %v4float + %29 = OpTypeFunction %void %v4float %vertex_main_out = OpTypeStruct %v4float - %38 = OpTypeFunction %vertex_main_out + %37 = OpTypeFunction %vertex_main_out %float_1 = OpConstant %float 1 %textureLoad_6273b1 = OpFunction %void None %14 %17 = OpLabel %res = OpVariable %_ptr_Function_float Function %8 - OpStore %res %float_0 - %23 = OpLoad %11 %arg_0 - %22 = OpImageFetch %v4float %23 %26 Sample %int_1 - %21 = OpCompositeExtract %float %22 0 - %28 = OpCompositeConstruct %v4float %21 %float_0 %float_0 %float_0 - %29 = OpCompositeExtract %float %28 0 - OpStore %res %29 + OpStore %res %8 + %22 = OpLoad %11 %arg_0 + %21 = OpImageFetch %v4float %22 %25 Sample %int_1 + %20 = OpCompositeExtract %float %21 0 + %27 = OpCompositeConstruct %v4float %20 %8 %8 %8 + %28 = OpCompositeExtract %float %27 0 + OpStore %res %28 OpReturn OpFunctionEnd -%tint_symbol_2 = OpFunction %void None %30 +%tint_symbol_2 = OpFunction %void None %29 %tint_symbol = OpFunctionParameter %v4float - %33 = OpLabel + %32 = OpLabel OpStore %tint_symbol_1 %tint_symbol OpReturn OpFunctionEnd %vertex_main_1 = OpFunction %void None %14 - %35 = OpLabel - %36 = OpFunctionCall %void %textureLoad_6273b1 - %37 = OpFunctionCall %void %tint_symbol_2 %5 + %34 = OpLabel + %35 = OpFunctionCall %void %textureLoad_6273b1 + %36 = OpFunctionCall %void %tint_symbol_2 %5 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %vertex_main_out None %38 - %41 = OpLabel - %42 = OpFunctionCall %void %vertex_main_1 - %43 = OpLoad %v4float %tint_symbol_1 - %44 = OpCompositeConstruct %vertex_main_out %43 - OpReturnValue %44 +%vertex_main_inner = OpFunction %vertex_main_out None %37 + %40 = OpLabel + %41 = OpFunctionCall %void %vertex_main_1 + %42 = OpLoad %v4float %tint_symbol_1 + %43 = OpCompositeConstruct %vertex_main_out %42 + OpReturnValue %43 OpFunctionEnd %vertex_main = OpFunction %void None %14 - %46 = OpLabel - %47 = OpFunctionCall %vertex_main_out %vertex_main_inner - %48 = OpCompositeExtract %v4float %47 0 - OpStore %tint_symbol_1_1_1 %48 + %45 = OpLabel + %46 = OpFunctionCall %vertex_main_out %vertex_main_inner + %47 = OpCompositeExtract %v4float %46 0 + OpStore %tint_symbol_1_1_1 %47 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd %fragment_main_1 = OpFunction %void None %14 - %51 = OpLabel - %52 = OpFunctionCall %void %textureLoad_6273b1 + %50 = OpLabel + %51 = OpFunctionCall %void %textureLoad_6273b1 OpReturn OpFunctionEnd %fragment_main = OpFunction %void None %14 - %54 = OpLabel - %55 = OpFunctionCall %void %fragment_main_1 + %53 = OpLabel + %54 = OpFunctionCall %void %fragment_main_1 OpReturn OpFunctionEnd %compute_main_1 = OpFunction %void None %14 - %57 = OpLabel - %58 = OpFunctionCall %void %textureLoad_6273b1 + %56 = OpLabel + %57 = OpFunctionCall %void %textureLoad_6273b1 OpReturn OpFunctionEnd %compute_main = OpFunction %void None %14 - %60 = OpLabel - %61 = OpFunctionCall %void %compute_main_1 + %59 = OpLabel + %60 = OpFunctionCall %void %compute_main_1 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/textureLoad/texture_external_param.wgsl.expected.spvasm b/test/tint/builtins/textureLoad/texture_external_param.wgsl.expected.spvasm index b7d51afc21..52b2ea9626 100644 --- a/test/tint/builtins/textureLoad/texture_external_param.wgsl.expected.spvasm +++ b/test/tint/builtins/textureLoad/texture_external_param.wgsl.expected.spvasm @@ -107,7 +107,7 @@ %v2int = OpTypeVector %int 2 %61 = OpTypeFunction %v4float %11 %11 %v2int %ExternalTextureParams %uint_1 = OpConstant %uint 1 - %int_0 = OpConstant %int 0 + %78 = OpConstantNull %int %v2float = OpTypeVector %float 2 %float_1 = OpConstant %float 1 %105 = OpTypeFunction %v4float %11 %11 %ExternalTextureParams %v2int @@ -164,14 +164,14 @@ OpSelectionMerge %74 None OpBranchConditional %73 %75 %76 %75 = OpLabel - %77 = OpImageFetch %v4float %plane0 %coord Lod %int_0 + %77 = OpImageFetch %v4float %plane0 %coord Lod %78 %79 = OpVectorShuffle %v3float %77 %77 0 1 2 OpStore %color %79 OpBranch %74 %76 = OpLabel - %80 = OpImageFetch %v4float %plane0 %coord Lod %int_0 + %80 = OpImageFetch %v4float %plane0 %coord Lod %78 %81 = OpCompositeExtract %float %80 0 - %82 = OpImageFetch %v4float %plane1 %coord Lod %int_0 + %82 = OpImageFetch %v4float %plane1 %coord Lod %78 %84 = OpVectorShuffle %v2float %82 %82 0 1 %85 = OpCompositeExtract %float %84 0 %86 = OpCompositeExtract %float %84 1 diff --git a/test/tint/builtins/textureLoad/texture_param.wgsl.expected.spvasm b/test/tint/builtins/textureLoad/texture_param.wgsl.expected.spvasm index b292e121d8..4345ed19fe 100644 --- a/test/tint/builtins/textureLoad/texture_param.wgsl.expected.spvasm +++ b/test/tint/builtins/textureLoad/texture_param.wgsl.expected.spvasm @@ -45,7 +45,7 @@ %void = OpTypeVoid %22 = OpTypeFunction %void %28 = OpConstantNull %v2int - %int_0 = OpConstant %int 0 + %29 = OpConstantNull %int %_ptr_Function_v4int = OpTypePointer Function %v4int %32 = OpConstantNull %v4int %33 = OpTypeFunction %v4float @@ -62,7 +62,7 @@ %25 = OpLabel %res = OpVariable %_ptr_Function_v4int Function %32 %27 = OpLoad %11 %arg_0 - %26 = OpFunctionCall %v4int %textureLoad2d %27 %28 %int_0 + %26 = OpFunctionCall %v4int %textureLoad2d %27 %28 %29 OpStore %res %26 OpReturn OpFunctionEnd diff --git a/test/tint/builtins/textureNumSamples/depth_ms.spvasm.expected.spvasm b/test/tint/builtins/textureNumSamples/depth_ms.spvasm.expected.spvasm index 5844481871..9c7f8a5955 100644 --- a/test/tint/builtins/textureNumSamples/depth_ms.spvasm.expected.spvasm +++ b/test/tint/builtins/textureNumSamples/depth_ms.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 57 +; Bound: 56 ; Schema: 0 OpCapability Shader OpCapability ImageQuery @@ -49,66 +49,65 @@ %void = OpTypeVoid %14 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %19 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %22 = OpConstantNull %int - %25 = OpTypeFunction %void %v4float + %24 = OpTypeFunction %void %v4float %vertex_main_out = OpTypeStruct %v4float - %33 = OpTypeFunction %vertex_main_out + %32 = OpTypeFunction %vertex_main_out %float_1 = OpConstant %float 1 %textureNumSamples_a3c8a0 = OpFunction %void None %14 %17 = OpLabel - %res = OpVariable %_ptr_Function_int Function %22 - OpStore %res %int_0 - %24 = OpLoad %11 %arg_0 - %23 = OpImageQuerySamples %int %24 - OpStore %res %23 + %res = OpVariable %_ptr_Function_int Function %19 + OpStore %res %19 + %23 = OpLoad %11 %arg_0 + %22 = OpImageQuerySamples %int %23 + OpStore %res %22 OpReturn OpFunctionEnd -%tint_symbol_2 = OpFunction %void None %25 +%tint_symbol_2 = OpFunction %void None %24 %tint_symbol = OpFunctionParameter %v4float - %28 = OpLabel + %27 = OpLabel OpStore %tint_symbol_1 %tint_symbol OpReturn OpFunctionEnd %vertex_main_1 = OpFunction %void None %14 - %30 = OpLabel - %31 = OpFunctionCall %void %textureNumSamples_a3c8a0 - %32 = OpFunctionCall %void %tint_symbol_2 %5 + %29 = OpLabel + %30 = OpFunctionCall %void %textureNumSamples_a3c8a0 + %31 = OpFunctionCall %void %tint_symbol_2 %5 OpReturn OpFunctionEnd -%vertex_main_inner = OpFunction %vertex_main_out None %33 - %36 = OpLabel - %37 = OpFunctionCall %void %vertex_main_1 - %38 = OpLoad %v4float %tint_symbol_1 - %39 = OpCompositeConstruct %vertex_main_out %38 - OpReturnValue %39 +%vertex_main_inner = OpFunction %vertex_main_out None %32 + %35 = OpLabel + %36 = OpFunctionCall %void %vertex_main_1 + %37 = OpLoad %v4float %tint_symbol_1 + %38 = OpCompositeConstruct %vertex_main_out %37 + OpReturnValue %38 OpFunctionEnd %vertex_main = OpFunction %void None %14 - %41 = OpLabel - %42 = OpFunctionCall %vertex_main_out %vertex_main_inner - %43 = OpCompositeExtract %v4float %42 0 - OpStore %tint_symbol_1_1_1 %43 + %40 = OpLabel + %41 = OpFunctionCall %vertex_main_out %vertex_main_inner + %42 = OpCompositeExtract %v4float %41 0 + OpStore %tint_symbol_1_1_1 %42 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd %fragment_main_1 = OpFunction %void None %14 - %46 = OpLabel - %47 = OpFunctionCall %void %textureNumSamples_a3c8a0 + %45 = OpLabel + %46 = OpFunctionCall %void %textureNumSamples_a3c8a0 OpReturn OpFunctionEnd %fragment_main = OpFunction %void None %14 - %49 = OpLabel - %50 = OpFunctionCall %void %fragment_main_1 + %48 = OpLabel + %49 = OpFunctionCall %void %fragment_main_1 OpReturn OpFunctionEnd %compute_main_1 = OpFunction %void None %14 - %52 = OpLabel - %53 = OpFunctionCall %void %textureNumSamples_a3c8a0 + %51 = OpLabel + %52 = OpFunctionCall %void %textureNumSamples_a3c8a0 OpReturn OpFunctionEnd %compute_main = OpFunction %void None %14 - %55 = OpLabel - %56 = OpFunctionCall %void %compute_main_1 + %54 = OpLabel + %55 = OpFunctionCall %void %compute_main_1 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/bit-and/scalar-scalar/bool.wgsl.expected.spvasm b/test/tint/expressions/binary/bit-and/scalar-scalar/bool.wgsl.expected.spvasm index a3279258fb..7f27a16fc0 100644 --- a/test/tint/expressions/binary/bit-and/scalar-scalar/bool.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/bit-and/scalar-scalar/bool.wgsl.expected.spvasm @@ -12,9 +12,9 @@ %1 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool - %false = OpConstantFalse %bool + %7 = OpConstantNull %bool %f = OpFunction %void None %1 %4 = OpLabel - %8 = OpLogicalAnd %bool %true %false + %8 = OpLogicalAnd %bool %true %7 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_constant/scalar-scalar/f32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_constant/scalar-scalar/f32.wgsl.expected.spvasm index aba66b3f77..c7d8708815 100644 --- a/test/tint/expressions/binary/div_by_zero/by_constant/scalar-scalar/f32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_constant/scalar-scalar/f32.wgsl.expected.spvasm @@ -12,9 +12,9 @@ %1 = OpTypeFunction %void %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 - %float_0 = OpConstant %float 0 + %7 = OpConstantNull %float %f = OpFunction %void None %1 %4 = OpLabel - %8 = OpFDiv %float %float_1 %float_0 + %8 = OpFDiv %float %float_1 %7 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_constant/scalar-scalar/i32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_constant/scalar-scalar/i32.wgsl.expected.spvasm index 47589eb15f..fa188bd8fe 100644 --- a/test/tint/expressions/binary/div_by_zero/by_constant/scalar-scalar/i32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_constant/scalar-scalar/i32.wgsl.expected.spvasm @@ -12,9 +12,9 @@ %1 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 - %int_0 = OpConstant %int 0 + %7 = OpConstantNull %int %f = OpFunction %void None %1 %4 = OpLabel - %8 = OpSDiv %int %int_1 %int_0 + %8 = OpSDiv %int %int_1 %7 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_constant/scalar-scalar/u32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_constant/scalar-scalar/u32.wgsl.expected.spvasm index 96e2a307e6..57df98086c 100644 --- a/test/tint/expressions/binary/div_by_zero/by_constant/scalar-scalar/u32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_constant/scalar-scalar/u32.wgsl.expected.spvasm @@ -12,9 +12,9 @@ %1 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 - %uint_0 = OpConstant %uint 0 + %7 = OpConstantNull %uint %f = OpFunction %void None %1 %4 = OpLabel - %8 = OpUDiv %uint %uint_1 %uint_0 + %8 = OpUDiv %uint %uint_1 %7 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_constant/vec3-scalar/f32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_constant/vec3-scalar/f32.wgsl.expected.spvasm index cc78cc9a86..f14f5aaea9 100644 --- a/test/tint/expressions/binary/div_by_zero/by_constant/vec3-scalar/f32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_constant/vec3-scalar/f32.wgsl.expected.spvasm @@ -16,13 +16,13 @@ %float_2 = OpConstant %float 2 %float_3 = OpConstant %float 3 %10 = OpConstantComposite %v3float %float_1 %float_2 %float_3 - %float_0 = OpConstant %float 0 + %11 = OpConstantNull %float %_ptr_Function_v3float = OpTypePointer Function %v3float %15 = OpConstantNull %v3float %f = OpFunction %void None %1 %4 = OpLabel %13 = OpVariable %_ptr_Function_v3float Function %15 - %16 = OpCompositeConstruct %v3float %float_0 %float_0 %float_0 + %16 = OpCompositeConstruct %v3float %11 %11 %11 %12 = OpFDiv %v3float %10 %16 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_constant/vec3-scalar/i32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_constant/vec3-scalar/i32.wgsl.expected.spvasm index 7f5c03fff7..af40beba9b 100644 --- a/test/tint/expressions/binary/div_by_zero/by_constant/vec3-scalar/i32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_constant/vec3-scalar/i32.wgsl.expected.spvasm @@ -16,13 +16,13 @@ %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %10 = OpConstantComposite %v3int %int_1 %int_2 %int_3 - %int_0 = OpConstant %int 0 + %11 = OpConstantNull %int %_ptr_Function_v3int = OpTypePointer Function %v3int %15 = OpConstantNull %v3int %f = OpFunction %void None %1 %4 = OpLabel %13 = OpVariable %_ptr_Function_v3int Function %15 - %16 = OpCompositeConstruct %v3int %int_0 %int_0 %int_0 + %16 = OpCompositeConstruct %v3int %11 %11 %11 %12 = OpSDiv %v3int %10 %16 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_constant/vec3-scalar/u32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_constant/vec3-scalar/u32.wgsl.expected.spvasm index a81a4c231d..2a83009118 100644 --- a/test/tint/expressions/binary/div_by_zero/by_constant/vec3-scalar/u32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_constant/vec3-scalar/u32.wgsl.expected.spvasm @@ -16,13 +16,13 @@ %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %10 = OpConstantComposite %v3uint %uint_1 %uint_2 %uint_3 - %uint_0 = OpConstant %uint 0 + %11 = OpConstantNull %uint %_ptr_Function_v3uint = OpTypePointer Function %v3uint %15 = OpConstantNull %v3uint %f = OpFunction %void None %1 %4 = OpLabel %13 = OpVariable %_ptr_Function_v3uint Function %15 - %16 = OpCompositeConstruct %v3uint %uint_0 %uint_0 %uint_0 + %16 = OpCompositeConstruct %v3uint %11 %11 %11 %12 = OpUDiv %v3uint %10 %16 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_expression/scalar-scalar/f32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_expression/scalar-scalar/f32.wgsl.expected.spvasm index c4eaf69931..ebfbdb58d4 100644 --- a/test/tint/expressions/binary/div_by_zero/by_expression/scalar-scalar/f32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_expression/scalar-scalar/f32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 17 +; Bound: 16 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -16,17 +16,16 @@ %float_1 = OpConstant %float 1 %_ptr_Function_float = OpTypePointer Function %float %9 = OpConstantNull %float - %float_0 = OpConstant %float 0 %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_float Function %9 %b = OpVariable %_ptr_Function_float Function %9 OpStore %a %float_1 - OpStore %b %float_0 - %12 = OpLoad %float %a + OpStore %b %9 + %11 = OpLoad %float %a + %12 = OpLoad %float %b %13 = OpLoad %float %b - %14 = OpLoad %float %b - %15 = OpFAdd %float %13 %14 - %16 = OpFDiv %float %12 %15 + %14 = OpFAdd %float %12 %13 + %15 = OpFDiv %float %11 %14 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_expression/scalar-scalar/i32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_expression/scalar-scalar/i32.wgsl.expected.spvasm index e1a8969c5f..2cad16a763 100644 --- a/test/tint/expressions/binary/div_by_zero/by_expression/scalar-scalar/i32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_expression/scalar-scalar/i32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 17 +; Bound: 16 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -16,17 +16,16 @@ %int_1 = OpConstant %int 1 %_ptr_Function_int = OpTypePointer Function %int %9 = OpConstantNull %int - %int_0 = OpConstant %int 0 %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_int Function %9 %b = OpVariable %_ptr_Function_int Function %9 OpStore %a %int_1 - OpStore %b %int_0 - %12 = OpLoad %int %a + OpStore %b %9 + %11 = OpLoad %int %a + %12 = OpLoad %int %b %13 = OpLoad %int %b - %14 = OpLoad %int %b - %15 = OpIAdd %int %13 %14 - %16 = OpSDiv %int %12 %15 + %14 = OpIAdd %int %12 %13 + %15 = OpSDiv %int %11 %14 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_expression/scalar-scalar/u32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_expression/scalar-scalar/u32.wgsl.expected.spvasm index 8d771cca2e..f245f406fb 100644 --- a/test/tint/expressions/binary/div_by_zero/by_expression/scalar-scalar/u32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_expression/scalar-scalar/u32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 17 +; Bound: 16 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -16,17 +16,16 @@ %uint_1 = OpConstant %uint 1 %_ptr_Function_uint = OpTypePointer Function %uint %9 = OpConstantNull %uint - %uint_0 = OpConstant %uint 0 %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_uint Function %9 %b = OpVariable %_ptr_Function_uint Function %9 OpStore %a %uint_1 - OpStore %b %uint_0 - %12 = OpLoad %uint %a + OpStore %b %9 + %11 = OpLoad %uint %a + %12 = OpLoad %uint %b %13 = OpLoad %uint %b - %14 = OpLoad %uint %b - %15 = OpIAdd %uint %13 %14 - %16 = OpUDiv %uint %12 %15 + %14 = OpIAdd %uint %12 %13 + %15 = OpUDiv %uint %11 %14 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_expression/vec3-scalar/f32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_expression/vec3-scalar/f32.wgsl.expected.spvasm index 6f77e087d7..a8ab379116 100644 --- a/test/tint/expressions/binary/div_by_zero/by_expression/vec3-scalar/f32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_expression/vec3-scalar/f32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 25 +; Bound: 24 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -20,21 +20,20 @@ %10 = OpConstantComposite %v3float %float_1 %float_2 %float_3 %_ptr_Function_v3float = OpTypePointer Function %v3float %13 = OpConstantNull %v3float - %float_0 = OpConstant %float 0 + %14 = OpConstantNull %float %_ptr_Function_float = OpTypePointer Function %float - %17 = OpConstantNull %float %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_v3float Function %13 - %b = OpVariable %_ptr_Function_float Function %17 - %23 = OpVariable %_ptr_Function_v3float Function %13 + %b = OpVariable %_ptr_Function_float Function %14 + %22 = OpVariable %_ptr_Function_v3float Function %13 OpStore %a %10 - OpStore %b %float_0 - %18 = OpLoad %v3float %a + OpStore %b %14 + %17 = OpLoad %v3float %a + %18 = OpLoad %float %b %19 = OpLoad %float %b - %20 = OpLoad %float %b - %21 = OpFAdd %float %19 %20 - %24 = OpCompositeConstruct %v3float %21 %21 %21 - %22 = OpFDiv %v3float %18 %24 + %20 = OpFAdd %float %18 %19 + %23 = OpCompositeConstruct %v3float %20 %20 %20 + %21 = OpFDiv %v3float %17 %23 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_expression/vec3-scalar/i32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_expression/vec3-scalar/i32.wgsl.expected.spvasm index 755ab0e6d4..565dd46094 100644 --- a/test/tint/expressions/binary/div_by_zero/by_expression/vec3-scalar/i32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_expression/vec3-scalar/i32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 25 +; Bound: 24 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -20,21 +20,20 @@ %10 = OpConstantComposite %v3int %int_1 %int_2 %int_3 %_ptr_Function_v3int = OpTypePointer Function %v3int %13 = OpConstantNull %v3int - %int_0 = OpConstant %int 0 + %14 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %17 = OpConstantNull %int %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_v3int Function %13 - %b = OpVariable %_ptr_Function_int Function %17 - %23 = OpVariable %_ptr_Function_v3int Function %13 + %b = OpVariable %_ptr_Function_int Function %14 + %22 = OpVariable %_ptr_Function_v3int Function %13 OpStore %a %10 - OpStore %b %int_0 - %18 = OpLoad %v3int %a + OpStore %b %14 + %17 = OpLoad %v3int %a + %18 = OpLoad %int %b %19 = OpLoad %int %b - %20 = OpLoad %int %b - %21 = OpIAdd %int %19 %20 - %24 = OpCompositeConstruct %v3int %21 %21 %21 - %22 = OpSDiv %v3int %18 %24 + %20 = OpIAdd %int %18 %19 + %23 = OpCompositeConstruct %v3int %20 %20 %20 + %21 = OpSDiv %v3int %17 %23 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_expression/vec3-scalar/u32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_expression/vec3-scalar/u32.wgsl.expected.spvasm index d83d27bf9d..726b715e18 100644 --- a/test/tint/expressions/binary/div_by_zero/by_expression/vec3-scalar/u32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_expression/vec3-scalar/u32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 25 +; Bound: 24 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -20,21 +20,20 @@ %10 = OpConstantComposite %v3uint %uint_1 %uint_2 %uint_3 %_ptr_Function_v3uint = OpTypePointer Function %v3uint %13 = OpConstantNull %v3uint - %uint_0 = OpConstant %uint 0 + %14 = OpConstantNull %uint %_ptr_Function_uint = OpTypePointer Function %uint - %17 = OpConstantNull %uint %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_v3uint Function %13 - %b = OpVariable %_ptr_Function_uint Function %17 - %23 = OpVariable %_ptr_Function_v3uint Function %13 + %b = OpVariable %_ptr_Function_uint Function %14 + %22 = OpVariable %_ptr_Function_v3uint Function %13 OpStore %a %10 - OpStore %b %uint_0 - %18 = OpLoad %v3uint %a + OpStore %b %14 + %17 = OpLoad %v3uint %a + %18 = OpLoad %uint %b %19 = OpLoad %uint %b - %20 = OpLoad %uint %b - %21 = OpIAdd %uint %19 %20 - %24 = OpCompositeConstruct %v3uint %21 %21 %21 - %22 = OpUDiv %v3uint %18 %24 + %20 = OpIAdd %uint %18 %19 + %23 = OpCompositeConstruct %v3uint %20 %20 %20 + %21 = OpUDiv %v3uint %17 %23 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_identifier/scalar-scalar/f32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_identifier/scalar-scalar/f32.wgsl.expected.spvasm index b1ac052be3..4c590c2985 100644 --- a/test/tint/expressions/binary/div_by_zero/by_identifier/scalar-scalar/f32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_identifier/scalar-scalar/f32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 15 +; Bound: 14 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -16,15 +16,14 @@ %float_1 = OpConstant %float 1 %_ptr_Function_float = OpTypePointer Function %float %9 = OpConstantNull %float - %float_0 = OpConstant %float 0 %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_float Function %9 %b = OpVariable %_ptr_Function_float Function %9 OpStore %a %float_1 - OpStore %b %float_0 - %12 = OpLoad %float %a - %13 = OpLoad %float %b - %14 = OpFDiv %float %12 %13 + OpStore %b %9 + %11 = OpLoad %float %a + %12 = OpLoad %float %b + %13 = OpFDiv %float %11 %12 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_identifier/scalar-scalar/i32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_identifier/scalar-scalar/i32.wgsl.expected.spvasm index 14dcaa0d45..96e1544311 100644 --- a/test/tint/expressions/binary/div_by_zero/by_identifier/scalar-scalar/i32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_identifier/scalar-scalar/i32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 15 +; Bound: 14 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -16,15 +16,14 @@ %int_1 = OpConstant %int 1 %_ptr_Function_int = OpTypePointer Function %int %9 = OpConstantNull %int - %int_0 = OpConstant %int 0 %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_int Function %9 %b = OpVariable %_ptr_Function_int Function %9 OpStore %a %int_1 - OpStore %b %int_0 - %12 = OpLoad %int %a - %13 = OpLoad %int %b - %14 = OpSDiv %int %12 %13 + OpStore %b %9 + %11 = OpLoad %int %a + %12 = OpLoad %int %b + %13 = OpSDiv %int %11 %12 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_identifier/scalar-scalar/u32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_identifier/scalar-scalar/u32.wgsl.expected.spvasm index 0519b51298..ce40e45760 100644 --- a/test/tint/expressions/binary/div_by_zero/by_identifier/scalar-scalar/u32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_identifier/scalar-scalar/u32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 15 +; Bound: 14 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -16,15 +16,14 @@ %uint_1 = OpConstant %uint 1 %_ptr_Function_uint = OpTypePointer Function %uint %9 = OpConstantNull %uint - %uint_0 = OpConstant %uint 0 %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_uint Function %9 %b = OpVariable %_ptr_Function_uint Function %9 OpStore %a %uint_1 - OpStore %b %uint_0 - %12 = OpLoad %uint %a - %13 = OpLoad %uint %b - %14 = OpUDiv %uint %12 %13 + OpStore %b %9 + %11 = OpLoad %uint %a + %12 = OpLoad %uint %b + %13 = OpUDiv %uint %11 %12 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_identifier/vec3-scalar/f32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_identifier/vec3-scalar/f32.wgsl.expected.spvasm index 292b63143f..c7112421ce 100644 --- a/test/tint/expressions/binary/div_by_zero/by_identifier/vec3-scalar/f32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_identifier/vec3-scalar/f32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 23 +; Bound: 22 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -20,19 +20,18 @@ %10 = OpConstantComposite %v3float %float_1 %float_2 %float_3 %_ptr_Function_v3float = OpTypePointer Function %v3float %13 = OpConstantNull %v3float - %float_0 = OpConstant %float 0 + %14 = OpConstantNull %float %_ptr_Function_float = OpTypePointer Function %float - %17 = OpConstantNull %float %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_v3float Function %13 - %b = OpVariable %_ptr_Function_float Function %17 - %21 = OpVariable %_ptr_Function_v3float Function %13 + %b = OpVariable %_ptr_Function_float Function %14 + %20 = OpVariable %_ptr_Function_v3float Function %13 OpStore %a %10 - OpStore %b %float_0 - %18 = OpLoad %v3float %a - %19 = OpLoad %float %b - %22 = OpCompositeConstruct %v3float %19 %19 %19 - %20 = OpFDiv %v3float %18 %22 + OpStore %b %14 + %17 = OpLoad %v3float %a + %18 = OpLoad %float %b + %21 = OpCompositeConstruct %v3float %18 %18 %18 + %19 = OpFDiv %v3float %17 %21 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_identifier/vec3-scalar/i32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_identifier/vec3-scalar/i32.wgsl.expected.spvasm index 35ceb4ac6c..88da03782c 100644 --- a/test/tint/expressions/binary/div_by_zero/by_identifier/vec3-scalar/i32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_identifier/vec3-scalar/i32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 23 +; Bound: 22 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -20,19 +20,18 @@ %10 = OpConstantComposite %v3int %int_1 %int_2 %int_3 %_ptr_Function_v3int = OpTypePointer Function %v3int %13 = OpConstantNull %v3int - %int_0 = OpConstant %int 0 + %14 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %17 = OpConstantNull %int %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_v3int Function %13 - %b = OpVariable %_ptr_Function_int Function %17 - %21 = OpVariable %_ptr_Function_v3int Function %13 + %b = OpVariable %_ptr_Function_int Function %14 + %20 = OpVariable %_ptr_Function_v3int Function %13 OpStore %a %10 - OpStore %b %int_0 - %18 = OpLoad %v3int %a - %19 = OpLoad %int %b - %22 = OpCompositeConstruct %v3int %19 %19 %19 - %20 = OpSDiv %v3int %18 %22 + OpStore %b %14 + %17 = OpLoad %v3int %a + %18 = OpLoad %int %b + %21 = OpCompositeConstruct %v3int %18 %18 %18 + %19 = OpSDiv %v3int %17 %21 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/div_by_zero/by_identifier/vec3-scalar/u32.wgsl.expected.spvasm b/test/tint/expressions/binary/div_by_zero/by_identifier/vec3-scalar/u32.wgsl.expected.spvasm index d04ce1e691..759be2a7bc 100644 --- a/test/tint/expressions/binary/div_by_zero/by_identifier/vec3-scalar/u32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/div_by_zero/by_identifier/vec3-scalar/u32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 23 +; Bound: 22 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -20,19 +20,18 @@ %10 = OpConstantComposite %v3uint %uint_1 %uint_2 %uint_3 %_ptr_Function_v3uint = OpTypePointer Function %v3uint %13 = OpConstantNull %v3uint - %uint_0 = OpConstant %uint 0 + %14 = OpConstantNull %uint %_ptr_Function_uint = OpTypePointer Function %uint - %17 = OpConstantNull %uint %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_v3uint Function %13 - %b = OpVariable %_ptr_Function_uint Function %17 - %21 = OpVariable %_ptr_Function_v3uint Function %13 + %b = OpVariable %_ptr_Function_uint Function %14 + %20 = OpVariable %_ptr_Function_v3uint Function %13 OpStore %a %10 - OpStore %b %uint_0 - %18 = OpLoad %v3uint %a - %19 = OpLoad %uint %b - %22 = OpCompositeConstruct %v3uint %19 %19 %19 - %20 = OpUDiv %v3uint %18 %22 + OpStore %b %14 + %17 = OpLoad %v3uint %a + %18 = OpLoad %uint %b + %21 = OpCompositeConstruct %v3uint %18 %18 %18 + %19 = OpUDiv %v3uint %17 %21 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/mod_by_zero/by_constant/scalar-scalar/f32.wgsl.expected.spvasm b/test/tint/expressions/binary/mod_by_zero/by_constant/scalar-scalar/f32.wgsl.expected.spvasm index 71bf9df9b6..8931a70cc5 100644 --- a/test/tint/expressions/binary/mod_by_zero/by_constant/scalar-scalar/f32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/mod_by_zero/by_constant/scalar-scalar/f32.wgsl.expected.spvasm @@ -12,9 +12,9 @@ %1 = OpTypeFunction %void %float = OpTypeFloat 32 %float_1 = OpConstant %float 1 - %float_0 = OpConstant %float 0 + %7 = OpConstantNull %float %f = OpFunction %void None %1 %4 = OpLabel - %8 = OpFRem %float %float_1 %float_0 + %8 = OpFRem %float %float_1 %7 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/mod_by_zero/by_constant/scalar-scalar/i32.wgsl.expected.spvasm b/test/tint/expressions/binary/mod_by_zero/by_constant/scalar-scalar/i32.wgsl.expected.spvasm index 37536a116e..bf9393fa49 100644 --- a/test/tint/expressions/binary/mod_by_zero/by_constant/scalar-scalar/i32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/mod_by_zero/by_constant/scalar-scalar/i32.wgsl.expected.spvasm @@ -12,9 +12,9 @@ %1 = OpTypeFunction %void %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 - %int_0 = OpConstant %int 0 + %7 = OpConstantNull %int %f = OpFunction %void None %1 %4 = OpLabel - %8 = OpSMod %int %int_1 %int_0 + %8 = OpSMod %int %int_1 %7 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/mod_by_zero/by_constant/scalar-scalar/u32.wgsl.expected.spvasm b/test/tint/expressions/binary/mod_by_zero/by_constant/scalar-scalar/u32.wgsl.expected.spvasm index e59fd6eae8..94d22635b1 100644 --- a/test/tint/expressions/binary/mod_by_zero/by_constant/scalar-scalar/u32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/mod_by_zero/by_constant/scalar-scalar/u32.wgsl.expected.spvasm @@ -12,9 +12,9 @@ %1 = OpTypeFunction %void %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 - %uint_0 = OpConstant %uint 0 + %7 = OpConstantNull %uint %f = OpFunction %void None %1 %4 = OpLabel - %8 = OpUMod %uint %uint_1 %uint_0 + %8 = OpUMod %uint %uint_1 %7 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/mod_by_zero/by_constant/vec3-scalar/i32.wgsl.expected.spvasm b/test/tint/expressions/binary/mod_by_zero/by_constant/vec3-scalar/i32.wgsl.expected.spvasm index ac1f1d7a1b..64592c9d9b 100644 --- a/test/tint/expressions/binary/mod_by_zero/by_constant/vec3-scalar/i32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/mod_by_zero/by_constant/vec3-scalar/i32.wgsl.expected.spvasm @@ -16,13 +16,13 @@ %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %10 = OpConstantComposite %v3int %int_1 %int_2 %int_3 - %int_0 = OpConstant %int 0 + %11 = OpConstantNull %int %_ptr_Function_v3int = OpTypePointer Function %v3int %15 = OpConstantNull %v3int %f = OpFunction %void None %1 %4 = OpLabel %13 = OpVariable %_ptr_Function_v3int Function %15 - %16 = OpCompositeConstruct %v3int %int_0 %int_0 %int_0 + %16 = OpCompositeConstruct %v3int %11 %11 %11 %12 = OpSMod %v3int %10 %16 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/mod_by_zero/by_constant/vec3-scalar/u32.wgsl.expected.spvasm b/test/tint/expressions/binary/mod_by_zero/by_constant/vec3-scalar/u32.wgsl.expected.spvasm index b8ce74fa9c..79e64e8ae9 100644 --- a/test/tint/expressions/binary/mod_by_zero/by_constant/vec3-scalar/u32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/mod_by_zero/by_constant/vec3-scalar/u32.wgsl.expected.spvasm @@ -16,13 +16,13 @@ %uint_2 = OpConstant %uint 2 %uint_3 = OpConstant %uint 3 %10 = OpConstantComposite %v3uint %uint_1 %uint_2 %uint_3 - %uint_0 = OpConstant %uint 0 + %11 = OpConstantNull %uint %_ptr_Function_v3uint = OpTypePointer Function %v3uint %15 = OpConstantNull %v3uint %f = OpFunction %void None %1 %4 = OpLabel %13 = OpVariable %_ptr_Function_v3uint Function %15 - %16 = OpCompositeConstruct %v3uint %uint_0 %uint_0 %uint_0 + %16 = OpCompositeConstruct %v3uint %11 %11 %11 %12 = OpUMod %v3uint %10 %16 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/mod_by_zero/by_expression/scalar-scalar/f32.wgsl.expected.spvasm b/test/tint/expressions/binary/mod_by_zero/by_expression/scalar-scalar/f32.wgsl.expected.spvasm index 33268b0b64..02c2aa5ae1 100644 --- a/test/tint/expressions/binary/mod_by_zero/by_expression/scalar-scalar/f32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/mod_by_zero/by_expression/scalar-scalar/f32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 17 +; Bound: 16 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -16,17 +16,16 @@ %float_1 = OpConstant %float 1 %_ptr_Function_float = OpTypePointer Function %float %9 = OpConstantNull %float - %float_0 = OpConstant %float 0 %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_float Function %9 %b = OpVariable %_ptr_Function_float Function %9 OpStore %a %float_1 - OpStore %b %float_0 - %12 = OpLoad %float %a + OpStore %b %9 + %11 = OpLoad %float %a + %12 = OpLoad %float %b %13 = OpLoad %float %b - %14 = OpLoad %float %b - %15 = OpFAdd %float %13 %14 - %16 = OpFRem %float %12 %15 + %14 = OpFAdd %float %12 %13 + %15 = OpFRem %float %11 %14 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/mod_by_zero/by_expression/scalar-scalar/i32.wgsl.expected.spvasm b/test/tint/expressions/binary/mod_by_zero/by_expression/scalar-scalar/i32.wgsl.expected.spvasm index a37441fe4d..fac854f6d1 100644 --- a/test/tint/expressions/binary/mod_by_zero/by_expression/scalar-scalar/i32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/mod_by_zero/by_expression/scalar-scalar/i32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 17 +; Bound: 16 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -16,17 +16,16 @@ %int_1 = OpConstant %int 1 %_ptr_Function_int = OpTypePointer Function %int %9 = OpConstantNull %int - %int_0 = OpConstant %int 0 %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_int Function %9 %b = OpVariable %_ptr_Function_int Function %9 OpStore %a %int_1 - OpStore %b %int_0 - %12 = OpLoad %int %a + OpStore %b %9 + %11 = OpLoad %int %a + %12 = OpLoad %int %b %13 = OpLoad %int %b - %14 = OpLoad %int %b - %15 = OpIAdd %int %13 %14 - %16 = OpSMod %int %12 %15 + %14 = OpIAdd %int %12 %13 + %15 = OpSMod %int %11 %14 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/mod_by_zero/by_expression/scalar-scalar/u32.wgsl.expected.spvasm b/test/tint/expressions/binary/mod_by_zero/by_expression/scalar-scalar/u32.wgsl.expected.spvasm index ae27d46639..ca8d7a50ef 100644 --- a/test/tint/expressions/binary/mod_by_zero/by_expression/scalar-scalar/u32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/mod_by_zero/by_expression/scalar-scalar/u32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 17 +; Bound: 16 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -16,17 +16,16 @@ %uint_1 = OpConstant %uint 1 %_ptr_Function_uint = OpTypePointer Function %uint %9 = OpConstantNull %uint - %uint_0 = OpConstant %uint 0 %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_uint Function %9 %b = OpVariable %_ptr_Function_uint Function %9 OpStore %a %uint_1 - OpStore %b %uint_0 - %12 = OpLoad %uint %a + OpStore %b %9 + %11 = OpLoad %uint %a + %12 = OpLoad %uint %b %13 = OpLoad %uint %b - %14 = OpLoad %uint %b - %15 = OpIAdd %uint %13 %14 - %16 = OpUMod %uint %12 %15 + %14 = OpIAdd %uint %12 %13 + %15 = OpUMod %uint %11 %14 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/mod_by_zero/by_expression/vec3-scalar/i32.wgsl.expected.spvasm b/test/tint/expressions/binary/mod_by_zero/by_expression/vec3-scalar/i32.wgsl.expected.spvasm index d9dd3f1a99..1b579c4a1e 100644 --- a/test/tint/expressions/binary/mod_by_zero/by_expression/vec3-scalar/i32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/mod_by_zero/by_expression/vec3-scalar/i32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 25 +; Bound: 24 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -20,21 +20,20 @@ %10 = OpConstantComposite %v3int %int_1 %int_2 %int_3 %_ptr_Function_v3int = OpTypePointer Function %v3int %13 = OpConstantNull %v3int - %int_0 = OpConstant %int 0 + %14 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %17 = OpConstantNull %int %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_v3int Function %13 - %b = OpVariable %_ptr_Function_int Function %17 - %23 = OpVariable %_ptr_Function_v3int Function %13 + %b = OpVariable %_ptr_Function_int Function %14 + %22 = OpVariable %_ptr_Function_v3int Function %13 OpStore %a %10 - OpStore %b %int_0 - %18 = OpLoad %v3int %a + OpStore %b %14 + %17 = OpLoad %v3int %a + %18 = OpLoad %int %b %19 = OpLoad %int %b - %20 = OpLoad %int %b - %21 = OpIAdd %int %19 %20 - %24 = OpCompositeConstruct %v3int %21 %21 %21 - %22 = OpSMod %v3int %18 %24 + %20 = OpIAdd %int %18 %19 + %23 = OpCompositeConstruct %v3int %20 %20 %20 + %21 = OpSMod %v3int %17 %23 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/mod_by_zero/by_expression/vec3-scalar/u32.wgsl.expected.spvasm b/test/tint/expressions/binary/mod_by_zero/by_expression/vec3-scalar/u32.wgsl.expected.spvasm index 78e1a7eb2e..4676fea349 100644 --- a/test/tint/expressions/binary/mod_by_zero/by_expression/vec3-scalar/u32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/mod_by_zero/by_expression/vec3-scalar/u32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 25 +; Bound: 24 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -20,21 +20,20 @@ %10 = OpConstantComposite %v3uint %uint_1 %uint_2 %uint_3 %_ptr_Function_v3uint = OpTypePointer Function %v3uint %13 = OpConstantNull %v3uint - %uint_0 = OpConstant %uint 0 + %14 = OpConstantNull %uint %_ptr_Function_uint = OpTypePointer Function %uint - %17 = OpConstantNull %uint %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_v3uint Function %13 - %b = OpVariable %_ptr_Function_uint Function %17 - %23 = OpVariable %_ptr_Function_v3uint Function %13 + %b = OpVariable %_ptr_Function_uint Function %14 + %22 = OpVariable %_ptr_Function_v3uint Function %13 OpStore %a %10 - OpStore %b %uint_0 - %18 = OpLoad %v3uint %a + OpStore %b %14 + %17 = OpLoad %v3uint %a + %18 = OpLoad %uint %b %19 = OpLoad %uint %b - %20 = OpLoad %uint %b - %21 = OpIAdd %uint %19 %20 - %24 = OpCompositeConstruct %v3uint %21 %21 %21 - %22 = OpUMod %v3uint %18 %24 + %20 = OpIAdd %uint %18 %19 + %23 = OpCompositeConstruct %v3uint %20 %20 %20 + %21 = OpUMod %v3uint %17 %23 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/mod_by_zero/by_identifier/scalar-scalar/f32.wgsl.expected.spvasm b/test/tint/expressions/binary/mod_by_zero/by_identifier/scalar-scalar/f32.wgsl.expected.spvasm index 14b6b443af..2ba1bacc70 100644 --- a/test/tint/expressions/binary/mod_by_zero/by_identifier/scalar-scalar/f32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/mod_by_zero/by_identifier/scalar-scalar/f32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 15 +; Bound: 14 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -16,15 +16,14 @@ %float_1 = OpConstant %float 1 %_ptr_Function_float = OpTypePointer Function %float %9 = OpConstantNull %float - %float_0 = OpConstant %float 0 %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_float Function %9 %b = OpVariable %_ptr_Function_float Function %9 OpStore %a %float_1 - OpStore %b %float_0 - %12 = OpLoad %float %a - %13 = OpLoad %float %b - %14 = OpFRem %float %12 %13 + OpStore %b %9 + %11 = OpLoad %float %a + %12 = OpLoad %float %b + %13 = OpFRem %float %11 %12 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/mod_by_zero/by_identifier/scalar-scalar/i32.wgsl.expected.spvasm b/test/tint/expressions/binary/mod_by_zero/by_identifier/scalar-scalar/i32.wgsl.expected.spvasm index f942f0b9bb..68aabf4ccb 100644 --- a/test/tint/expressions/binary/mod_by_zero/by_identifier/scalar-scalar/i32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/mod_by_zero/by_identifier/scalar-scalar/i32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 15 +; Bound: 14 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -16,15 +16,14 @@ %int_1 = OpConstant %int 1 %_ptr_Function_int = OpTypePointer Function %int %9 = OpConstantNull %int - %int_0 = OpConstant %int 0 %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_int Function %9 %b = OpVariable %_ptr_Function_int Function %9 OpStore %a %int_1 - OpStore %b %int_0 - %12 = OpLoad %int %a - %13 = OpLoad %int %b - %14 = OpSMod %int %12 %13 + OpStore %b %9 + %11 = OpLoad %int %a + %12 = OpLoad %int %b + %13 = OpSMod %int %11 %12 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/mod_by_zero/by_identifier/scalar-scalar/u32.wgsl.expected.spvasm b/test/tint/expressions/binary/mod_by_zero/by_identifier/scalar-scalar/u32.wgsl.expected.spvasm index 8d29bb63e8..62435a14ba 100644 --- a/test/tint/expressions/binary/mod_by_zero/by_identifier/scalar-scalar/u32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/mod_by_zero/by_identifier/scalar-scalar/u32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 15 +; Bound: 14 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -16,15 +16,14 @@ %uint_1 = OpConstant %uint 1 %_ptr_Function_uint = OpTypePointer Function %uint %9 = OpConstantNull %uint - %uint_0 = OpConstant %uint 0 %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_uint Function %9 %b = OpVariable %_ptr_Function_uint Function %9 OpStore %a %uint_1 - OpStore %b %uint_0 - %12 = OpLoad %uint %a - %13 = OpLoad %uint %b - %14 = OpUMod %uint %12 %13 + OpStore %b %9 + %11 = OpLoad %uint %a + %12 = OpLoad %uint %b + %13 = OpUMod %uint %11 %12 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/mod_by_zero/by_identifier/vec3-scalar/i32.wgsl.expected.spvasm b/test/tint/expressions/binary/mod_by_zero/by_identifier/vec3-scalar/i32.wgsl.expected.spvasm index f25b33386b..d5f44f4be2 100644 --- a/test/tint/expressions/binary/mod_by_zero/by_identifier/vec3-scalar/i32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/mod_by_zero/by_identifier/vec3-scalar/i32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 23 +; Bound: 22 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -20,19 +20,18 @@ %10 = OpConstantComposite %v3int %int_1 %int_2 %int_3 %_ptr_Function_v3int = OpTypePointer Function %v3int %13 = OpConstantNull %v3int - %int_0 = OpConstant %int 0 + %14 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %17 = OpConstantNull %int %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_v3int Function %13 - %b = OpVariable %_ptr_Function_int Function %17 - %21 = OpVariable %_ptr_Function_v3int Function %13 + %b = OpVariable %_ptr_Function_int Function %14 + %20 = OpVariable %_ptr_Function_v3int Function %13 OpStore %a %10 - OpStore %b %int_0 - %18 = OpLoad %v3int %a - %19 = OpLoad %int %b - %22 = OpCompositeConstruct %v3int %19 %19 %19 - %20 = OpSMod %v3int %18 %22 + OpStore %b %14 + %17 = OpLoad %v3int %a + %18 = OpLoad %int %b + %21 = OpCompositeConstruct %v3int %18 %18 %18 + %19 = OpSMod %v3int %17 %21 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/binary/mod_by_zero/by_identifier/vec3-scalar/u32.wgsl.expected.spvasm b/test/tint/expressions/binary/mod_by_zero/by_identifier/vec3-scalar/u32.wgsl.expected.spvasm index 0965b4a729..36e59096a8 100644 --- a/test/tint/expressions/binary/mod_by_zero/by_identifier/vec3-scalar/u32.wgsl.expected.spvasm +++ b/test/tint/expressions/binary/mod_by_zero/by_identifier/vec3-scalar/u32.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 23 +; Bound: 22 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -20,19 +20,18 @@ %10 = OpConstantComposite %v3uint %uint_1 %uint_2 %uint_3 %_ptr_Function_v3uint = OpTypePointer Function %v3uint %13 = OpConstantNull %v3uint - %uint_0 = OpConstant %uint 0 + %14 = OpConstantNull %uint %_ptr_Function_uint = OpTypePointer Function %uint - %17 = OpConstantNull %uint %f = OpFunction %void None %1 %4 = OpLabel %a = OpVariable %_ptr_Function_v3uint Function %13 - %b = OpVariable %_ptr_Function_uint Function %17 - %21 = OpVariable %_ptr_Function_v3uint Function %13 + %b = OpVariable %_ptr_Function_uint Function %14 + %20 = OpVariable %_ptr_Function_v3uint Function %13 OpStore %a %10 - OpStore %b %uint_0 - %18 = OpLoad %v3uint %a - %19 = OpLoad %uint %b - %22 = OpCompositeConstruct %v3uint %19 %19 %19 - %20 = OpUMod %v3uint %18 %22 + OpStore %b %14 + %17 = OpLoad %v3uint %a + %18 = OpLoad %uint %b + %21 = OpCompositeConstruct %v3uint %18 %18 %18 + %19 = OpUMod %v3uint %17 %21 OpReturn OpFunctionEnd diff --git a/test/tint/expressions/splat/expression/bool.wgsl.expected.spvasm b/test/tint/expressions/splat/expression/bool.wgsl.expected.spvasm index 7a6eb60e97..8bf9fa114e 100644 --- a/test/tint/expressions/splat/expression/bool.wgsl.expected.spvasm +++ b/test/tint/expressions/splat/expression/bool.wgsl.expected.spvasm @@ -17,7 +17,7 @@ %bool = OpTypeBool %v2bool = OpTypeVector %bool 2 %true = OpConstantTrue %bool - %false = OpConstantFalse %bool + %12 = OpConstantNull %bool %_ptr_Function_v2bool = OpTypePointer Function %v2bool %17 = OpConstantNull %v2bool %v3bool = OpTypeVector %bool 3 @@ -40,7 +40,7 @@ %11 = OpLabel OpBranch %10 %10 = OpLabel - %13 = OpPhi %bool %true %6 %false %11 + %13 = OpPhi %bool %true %6 %12 %11 %14 = OpCompositeConstruct %v2bool %13 %13 OpStore %v2 %14 OpSelectionMerge %19 None @@ -48,7 +48,7 @@ %20 = OpLabel OpBranch %19 %19 = OpLabel - %21 = OpPhi %bool %true %10 %false %20 + %21 = OpPhi %bool %true %10 %12 %20 %22 = OpCompositeConstruct %v3bool %21 %21 %21 OpStore %v3 %22 OpSelectionMerge %27 None @@ -56,7 +56,7 @@ %28 = OpLabel OpBranch %27 %27 = OpLabel - %29 = OpPhi %bool %true %19 %false %28 + %29 = OpPhi %bool %true %19 %12 %28 %30 = OpCompositeConstruct %v4bool %29 %29 %29 %29 OpStore %v4 %30 OpReturn diff --git a/test/tint/expressions/splat/var/bool.wgsl.expected.spvasm b/test/tint/expressions/splat/var/bool.wgsl.expected.spvasm index 155f6e6caa..7eee754994 100644 --- a/test/tint/expressions/splat/var/bool.wgsl.expected.spvasm +++ b/test/tint/expressions/splat/var/bool.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 34 +; Bound: 33 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -17,43 +17,42 @@ %1 = OpTypeFunction %void %bool = OpTypeBool %true = OpConstantTrue %bool - %false = OpConstantFalse %bool + %11 = OpConstantNull %bool %_ptr_Function_bool = OpTypePointer Function %bool - %15 = OpConstantNull %bool %v2bool = OpTypeVector %bool 2 %_ptr_Function_v2bool = OpTypePointer Function %v2bool - %21 = OpConstantNull %v2bool + %20 = OpConstantNull %v2bool %v3bool = OpTypeVector %bool 3 %_ptr_Function_v3bool = OpTypePointer Function %v3bool - %27 = OpConstantNull %v3bool + %26 = OpConstantNull %v3bool %v4bool = OpTypeVector %bool 4 %_ptr_Function_v4bool = OpTypePointer Function %v4bool - %33 = OpConstantNull %v4bool + %32 = OpConstantNull %v4bool %unused_entry_point = OpFunction %void None %1 %4 = OpLabel OpReturn OpFunctionEnd %f = OpFunction %void None %1 %6 = OpLabel - %v = OpVariable %_ptr_Function_bool Function %15 - %v2 = OpVariable %_ptr_Function_v2bool Function %21 - %v3 = OpVariable %_ptr_Function_v3bool Function %27 - %v4 = OpVariable %_ptr_Function_v4bool Function %33 + %v = OpVariable %_ptr_Function_bool Function %11 + %v2 = OpVariable %_ptr_Function_v2bool Function %20 + %v3 = OpVariable %_ptr_Function_v3bool Function %26 + %v4 = OpVariable %_ptr_Function_v4bool Function %32 OpSelectionMerge %9 None OpBranchConditional %true %9 %10 %10 = OpLabel OpBranch %9 %9 = OpLabel - %12 = OpPhi %bool %true %6 %false %10 + %12 = OpPhi %bool %true %6 %11 %10 OpStore %v %12 - %17 = OpLoad %bool %v - %18 = OpCompositeConstruct %v2bool %17 %17 - OpStore %v2 %18 - %23 = OpLoad %bool %v - %24 = OpCompositeConstruct %v3bool %23 %23 %23 - OpStore %v3 %24 - %29 = OpLoad %bool %v - %30 = OpCompositeConstruct %v4bool %29 %29 %29 %29 - OpStore %v4 %30 + %16 = OpLoad %bool %v + %17 = OpCompositeConstruct %v2bool %16 %16 + OpStore %v2 %17 + %22 = OpLoad %bool %v + %23 = OpCompositeConstruct %v3bool %22 %22 %22 + OpStore %v3 %23 + %28 = OpLoad %bool %v + %29 = OpCompositeConstruct %v4bool %28 %28 %28 %28 + OpStore %v4 %29 OpReturn OpFunctionEnd diff --git a/test/tint/layout/storage/mat2x2/stride/16.spvasm.expected.spvasm b/test/tint/layout/storage/mat2x2/stride/16.spvasm.expected.spvasm index 80b7d9793c..7427fec70b 100644 --- a/test/tint/layout/storage/mat2x2/stride/16.spvasm.expected.spvasm +++ b/test/tint/layout/storage/mat2x2/stride/16.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 44 +; Bound: 45 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -35,11 +35,12 @@ %ssbo = OpVariable %_ptr_StorageBuffer_SSBO StorageBuffer %mat2v2float = OpTypeMatrix %v2float 2 %10 = OpTypeFunction %mat2v2float %_arr_strided_arr_uint_2 - %uint_0 = OpConstant %uint 0 + %15 = OpConstantNull %uint %uint_1 = OpConstant %uint 1 %22 = OpTypeFunction %_arr_strided_arr_uint_2 %mat2v2float %void = OpTypeVoid %31 = OpTypeFunction %void + %uint_0 = OpConstant %uint 0 %_ptr_StorageBuffer__arr_strided_arr_uint_2 = OpTypePointer StorageBuffer %_arr_strided_arr_uint_2 %arr_to_mat2x2_stride_16 = OpFunction %mat2v2float None %10 %arr = OpFunctionParameter %_arr_strided_arr_uint_2 @@ -63,16 +64,16 @@ OpFunctionEnd %f_1 = OpFunction %void None %31 %34 = OpLabel - %37 = OpAccessChain %_ptr_StorageBuffer__arr_strided_arr_uint_2 %ssbo %uint_0 - %38 = OpLoad %_arr_strided_arr_uint_2 %37 - %35 = OpFunctionCall %mat2v2float %arr_to_mat2x2_stride_16 %38 - %39 = OpFunctionCall %_arr_strided_arr_uint_2 %mat2x2_stride_16_to_arr %35 - %40 = OpAccessChain %_ptr_StorageBuffer__arr_strided_arr_uint_2 %ssbo %uint_0 - OpStore %40 %39 + %38 = OpAccessChain %_ptr_StorageBuffer__arr_strided_arr_uint_2 %ssbo %uint_0 + %39 = OpLoad %_arr_strided_arr_uint_2 %38 + %35 = OpFunctionCall %mat2v2float %arr_to_mat2x2_stride_16 %39 + %40 = OpFunctionCall %_arr_strided_arr_uint_2 %mat2x2_stride_16_to_arr %35 + %41 = OpAccessChain %_ptr_StorageBuffer__arr_strided_arr_uint_2 %ssbo %uint_0 + OpStore %41 %40 OpReturn OpFunctionEnd %f = OpFunction %void None %31 - %42 = OpLabel - %43 = OpFunctionCall %void %f_1 + %43 = OpLabel + %44 = OpFunctionCall %void %f_1 OpReturn OpFunctionEnd diff --git a/test/tint/let/global/global.wgsl.expected.spvasm b/test/tint/let/global/global.wgsl.expected.spvasm index 6bbf8ad3a3..f9c63e2c4f 100644 --- a/test/tint/let/global/global.wgsl.expected.spvasm +++ b/test/tint/let/global/global.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 34 +; Bound: 32 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -48,17 +48,15 @@ %_arr_float_uint_10 = OpTypeArray %float %uint_10 %v9 = OpConstantNull %_arr_float_uint_10 %24 = OpTypeFunction %v4float - %float_0 = OpConstant %float 0 - %28 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %void = OpTypeVoid - %29 = OpTypeFunction %void + %27 = OpTypeFunction %void %main_inner = OpFunction %v4float None %24 %26 = OpLabel - OpReturnValue %28 + OpReturnValue %5 OpFunctionEnd - %main = OpFunction %void None %29 - %32 = OpLabel - %33 = OpFunctionCall %v4float %main_inner - OpStore %value %33 + %main = OpFunction %void None %27 + %30 = OpLabel + %31 = OpFunctionCall %v4float %main_inner + OpStore %value %31 OpReturn OpFunctionEnd diff --git a/test/tint/let/inferred/function.wgsl.expected.spvasm b/test/tint/let/inferred/function.wgsl.expected.spvasm index 3593a241ae..e3f36f6755 100644 --- a/test/tint/let/inferred/function.wgsl.expected.spvasm +++ b/test/tint/let/inferred/function.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 58 +; Bound: 56 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -50,10 +50,9 @@ %v3float = OpTypeVector %float 3 %40 = OpConstantComposite %v3float %float_1 %float_1 %float_1 %mat3v3float = OpTypeMatrix %v3float 3 + %42 = OpConstantComposite %mat3v3float %40 %40 %40 %43 = OpConstantComposite %MyStruct %float_1 %50 = OpTypeFunction %v4float - %float_0 = OpConstant %float 0 - %54 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %ret_i32 = OpFunction %int None %6 %9 = OpLabel OpReturnValue %int_1 @@ -76,7 +75,6 @@ OpFunctionEnd %let_decls = OpFunction %void None %31 %34 = OpLabel - %42 = OpCompositeConstruct %mat3v3float %40 %40 %40 %44 = OpFunctionCall %int %ret_i32 %45 = OpFunctionCall %uint %ret_u32 %46 = OpFunctionCall %float %ret_f32 @@ -87,11 +85,11 @@ OpFunctionEnd %main_inner = OpFunction %v4float None %50 %52 = OpLabel - OpReturnValue %54 + OpReturnValue %5 OpFunctionEnd %main = OpFunction %void None %31 - %56 = OpLabel - %57 = OpFunctionCall %v4float %main_inner - OpStore %value %57 + %54 = OpLabel + %55 = OpFunctionCall %v4float %main_inner + OpStore %value %55 OpReturn OpFunctionEnd diff --git a/test/tint/loops/continue_in_switch.wgsl.expected.spvasm b/test/tint/loops/continue_in_switch.wgsl.expected.spvasm index d9378ba27c..ec8a10115c 100644 --- a/test/tint/loops/continue_in_switch.wgsl.expected.spvasm +++ b/test/tint/loops/continue_in_switch.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 28 +; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -12,43 +12,42 @@ %void = OpTypeVoid %1 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %6 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %9 = OpConstantNull %int %int_4 = OpConstant %int 4 %bool = OpTypeBool %int_1 = OpConstant %int 1 %f = OpFunction %void None %1 %4 = OpLabel - %i = OpVariable %_ptr_Function_int Function %9 - OpStore %i %int_0 - OpBranch %10 - %10 = OpLabel - OpLoopMerge %11 %12 None - OpBranch %13 - %13 = OpLabel - %15 = OpLoad %int %i - %17 = OpSLessThan %bool %15 %int_4 - %14 = OpLogicalNot %bool %17 - OpSelectionMerge %19 None - OpBranchConditional %14 %20 %19 - %20 = OpLabel - OpBranch %11 - %19 = OpLabel - %22 = OpLoad %int %i - OpSelectionMerge %21 None - OpSwitch %22 %23 0 %24 - %24 = OpLabel - OpBranch %12 - %23 = OpLabel - OpBranch %21 - %21 = OpLabel + %i = OpVariable %_ptr_Function_int Function %6 + OpStore %i %6 + OpBranch %9 + %9 = OpLabel + OpLoopMerge %10 %11 None OpBranch %12 %12 = OpLabel - %25 = OpLoad %int %i - %27 = OpIAdd %int %25 %int_1 - OpStore %i %27 + %14 = OpLoad %int %i + %16 = OpSLessThan %bool %14 %int_4 + %13 = OpLogicalNot %bool %16 + OpSelectionMerge %18 None + OpBranchConditional %13 %19 %18 + %19 = OpLabel OpBranch %10 + %18 = OpLabel + %21 = OpLoad %int %i + OpSelectionMerge %20 None + OpSwitch %21 %22 0 %23 + %23 = OpLabel + OpBranch %11 + %22 = OpLabel + OpBranch %20 + %20 = OpLabel + OpBranch %11 %11 = OpLabel + %24 = OpLoad %int %i + %26 = OpIAdd %int %24 %int_1 + OpStore %i %26 + OpBranch %9 + %10 = OpLabel OpReturn OpFunctionEnd diff --git a/test/tint/out_of_order_decls/array/alias.wgsl.expected.spvasm b/test/tint/out_of_order_decls/array/alias.wgsl.expected.spvasm index 0daa352c19..8cb67b3a24 100644 --- a/test/tint/out_of_order_decls/array/alias.wgsl.expected.spvasm +++ b/test/tint/out_of_order_decls/array/alias.wgsl.expected.spvasm @@ -19,12 +19,12 @@ %A = OpVariable %_ptr_Private__arr_int_uint_4 Private %7 %void = OpTypeVoid %8 = OpTypeFunction %void - %int_0 = OpConstant %int 0 + %12 = OpConstantNull %int %_ptr_Private_int = OpTypePointer Private %int %int_1 = OpConstant %int 1 %f = OpFunction %void None %8 %11 = OpLabel - %14 = OpAccessChain %_ptr_Private_int %A %int_0 + %14 = OpAccessChain %_ptr_Private_int %A %12 OpStore %14 %int_1 OpReturn OpFunctionEnd diff --git a/test/tint/out_of_order_decls/array/struct.wgsl.expected.spvasm b/test/tint/out_of_order_decls/array/struct.wgsl.expected.spvasm index 317a4459c1..3358b89277 100644 --- a/test/tint/out_of_order_decls/array/struct.wgsl.expected.spvasm +++ b/test/tint/out_of_order_decls/array/struct.wgsl.expected.spvasm @@ -23,13 +23,13 @@ %A = OpVariable %_ptr_Private__arr_S_uint_4 Private %8 %void = OpTypeVoid %9 = OpTypeFunction %void - %int_0 = OpConstant %int 0 + %13 = OpConstantNull %int %_ptr_Private_S = OpTypePointer Private %S %int_1 = OpConstant %int 1 %17 = OpConstantComposite %S %int_1 %f = OpFunction %void None %9 %12 = OpLabel - %15 = OpAccessChain %_ptr_Private_S %A %int_0 + %15 = OpAccessChain %_ptr_Private_S %A %13 OpStore %15 %17 OpReturn OpFunctionEnd diff --git a/test/tint/ptr_ref/load/global/i32.spvasm.expected.spvasm b/test/tint/ptr_ref/load/global/i32.spvasm.expected.spvasm index c105555c7e..5aa12a3739 100644 --- a/test/tint/ptr_ref/load/global/i32.spvasm.expected.spvasm +++ b/test/tint/ptr_ref/load/global/i32.spvasm.expected.spvasm @@ -11,9 +11,9 @@ OpName %main_1 "main_1" OpName %main "main" %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %2 = OpConstantNull %int %_ptr_Private_int = OpTypePointer Private %int - %I = OpVariable %_ptr_Private_int Private %int_0 + %I = OpVariable %_ptr_Private_int Private %2 %void = OpTypeVoid %5 = OpTypeFunction %void %int_1 = OpConstant %int 1 diff --git a/test/tint/ptr_ref/load/local/i32.spvasm.expected.spvasm b/test/tint/ptr_ref/load/local/i32.spvasm.expected.spvasm index f5dfd09b77..65e31c289d 100644 --- a/test/tint/ptr_ref/load/local/i32.spvasm.expected.spvasm +++ b/test/tint/ptr_ref/load/local/i32.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 17 +; Bound: 16 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -13,22 +13,21 @@ %void = OpTypeVoid %1 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %6 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %9 = OpConstantNull %int %int_123 = OpConstant %int 123 %int_1 = OpConstant %int 1 %main_1 = OpFunction %void None %1 %4 = OpLabel - %i = OpVariable %_ptr_Function_int Function %9 - OpStore %i %int_0 + %i = OpVariable %_ptr_Function_int Function %6 + OpStore %i %6 OpStore %i %int_123 - %11 = OpLoad %int %i - %13 = OpIAdd %int %11 %int_1 + %10 = OpLoad %int %i + %12 = OpIAdd %int %10 %int_1 OpReturn OpFunctionEnd %main = OpFunction %void None %1 - %15 = OpLabel - %16 = OpFunctionCall %void %main_1 + %14 = OpLabel + %15 = OpFunctionCall %void %main_1 OpReturn OpFunctionEnd diff --git a/test/tint/ptr_ref/load/param/ptr.spvasm.expected.spvasm b/test/tint/ptr_ref/load/param/ptr.spvasm.expected.spvasm index c487a58ed2..47d6500f74 100644 --- a/test/tint/ptr_ref/load/param/ptr.spvasm.expected.spvasm +++ b/test/tint/ptr_ref/load/param/ptr.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 25 +; Bound: 24 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -18,8 +18,7 @@ %1 = OpTypeFunction %int %int %_ptr_Function_int %void = OpTypeVoid %11 = OpTypeFunction %void - %int_0 = OpConstant %int 0 - %17 = OpConstantNull %int + %15 = OpConstantNull %int %int_123 = OpConstant %int 123 %func = OpFunction %int None %1 %value = OpFunctionParameter %int @@ -31,15 +30,15 @@ OpFunctionEnd %main_1 = OpFunction %void None %11 %14 = OpLabel - %i = OpVariable %_ptr_Function_int Function %17 - OpStore %i %int_0 + %i = OpVariable %_ptr_Function_int Function %15 + OpStore %i %15 OpStore %i %int_123 - %19 = OpLoad %int %i - %20 = OpFunctionCall %int %func %19 %i + %18 = OpLoad %int %i + %19 = OpFunctionCall %int %func %18 %i OpReturn OpFunctionEnd %main = OpFunction %void None %11 - %23 = OpLabel - %24 = OpFunctionCall %void %main_1 + %22 = OpLabel + %23 = OpFunctionCall %void %main_1 OpReturn OpFunctionEnd diff --git a/test/tint/ptr_ref/store/global/i32.spvasm.expected.spvasm b/test/tint/ptr_ref/store/global/i32.spvasm.expected.spvasm index dc2e27124d..2925d52ba2 100644 --- a/test/tint/ptr_ref/store/global/i32.spvasm.expected.spvasm +++ b/test/tint/ptr_ref/store/global/i32.spvasm.expected.spvasm @@ -11,9 +11,9 @@ OpName %main_1 "main_1" OpName %main "main" %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %2 = OpConstantNull %int %_ptr_Private_int = OpTypePointer Private %int - %I = OpVariable %_ptr_Private_int Private %int_0 + %I = OpVariable %_ptr_Private_int Private %2 %void = OpTypeVoid %5 = OpTypeFunction %void %int_123 = OpConstant %int 123 diff --git a/test/tint/ptr_ref/store/local/i32.spvasm.expected.spvasm b/test/tint/ptr_ref/store/local/i32.spvasm.expected.spvasm index 85a187aad3..424e127e6f 100644 --- a/test/tint/ptr_ref/store/local/i32.spvasm.expected.spvasm +++ b/test/tint/ptr_ref/store/local/i32.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 19 +; Bound: 18 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -13,26 +13,25 @@ %void = OpTypeVoid %1 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %6 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %9 = OpConstantNull %int %int_123 = OpConstant %int 123 %int_100 = OpConstant %int 100 %int_20 = OpConstant %int 20 %int_3 = OpConstant %int 3 %main_1 = OpFunction %void None %1 %4 = OpLabel - %i = OpVariable %_ptr_Function_int Function %9 - OpStore %i %int_0 + %i = OpVariable %_ptr_Function_int Function %6 + OpStore %i %6 OpStore %i %int_123 OpStore %i %int_123 - %13 = OpIAdd %int %int_100 %int_20 - %15 = OpIAdd %int %13 %int_3 - OpStore %i %15 + %12 = OpIAdd %int %int_100 %int_20 + %14 = OpIAdd %int %12 %int_3 + OpStore %i %14 OpReturn OpFunctionEnd %main = OpFunction %void None %1 - %17 = OpLabel - %18 = OpFunctionCall %void %main_1 + %16 = OpLabel + %17 = OpFunctionCall %void %main_1 OpReturn OpFunctionEnd diff --git a/test/tint/ptr_ref/store/param/ptr.spvasm.expected.spvasm b/test/tint/ptr_ref/store/param/ptr.spvasm.expected.spvasm index c4a8e196b6..54c9ae55e4 100644 --- a/test/tint/ptr_ref/store/param/ptr.spvasm.expected.spvasm +++ b/test/tint/ptr_ref/store/param/ptr.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 22 +; Bound: 21 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -18,8 +18,7 @@ %_ptr_Function_int = OpTypePointer Function %int %1 = OpTypeFunction %void %int %_ptr_Function_int %10 = OpTypeFunction %void - %int_0 = OpConstant %int 0 - %15 = OpConstantNull %int + %13 = OpConstantNull %int %int_123 = OpConstant %int 123 %func = OpFunction %void None %1 %value = OpFunctionParameter %int @@ -30,14 +29,14 @@ OpFunctionEnd %main_1 = OpFunction %void None %10 %12 = OpLabel - %i = OpVariable %_ptr_Function_int Function %15 - OpStore %i %int_0 + %i = OpVariable %_ptr_Function_int Function %13 + OpStore %i %13 OpStore %i %int_123 - %17 = OpFunctionCall %void %func %int_123 %i + %16 = OpFunctionCall %void %func %int_123 %i OpReturn OpFunctionEnd %main = OpFunction %void None %10 - %20 = OpLabel - %21 = OpFunctionCall %void %main_1 + %19 = OpLabel + %20 = OpFunctionCall %void %main_1 OpReturn OpFunctionEnd diff --git a/test/tint/samples/compute_boids.wgsl.expected.spvasm b/test/tint/samples/compute_boids.wgsl.expected.spvasm index e6305a77d6..d3abbb5382 100644 --- a/test/tint/samples/compute_boids.wgsl.expected.spvasm +++ b/test/tint/samples/compute_boids.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 280 +; Bound: 277 ; Schema: 0 OpCapability Shader %37 = OpExtInstImport "GLSL.std.450" @@ -116,24 +116,21 @@ %_ptr_Function_float = OpTypePointer Function %float %_ptr_Function_v2float = OpTypePointer Function %v2float %63 = OpConstantNull %v2float - %float_0 = OpConstant %float 0 %float_1 = OpConstant %float 1 %void = OpTypeVoid - %71 = OpTypeFunction %void - %79 = OpTypeFunction %v4float - %82 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 - %86 = OpTypeFunction %void %v3uint + %70 = OpTypeFunction %void + %78 = OpTypeFunction %v4float + %81 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1 + %85 = OpTypeFunction %void %v3uint %_ptr_Function_uint = OpTypePointer Function %uint - %93 = OpConstantNull %uint + %92 = OpConstantNull %uint %bool = OpTypeBool %uint_0 = OpConstant %uint 0 %_ptr_StorageBuffer_v2float = OpTypePointer StorageBuffer %v2float %uint_1 = OpConstant %uint 1 - %110 = OpConstantComposite %v2float %float_0 %float_0 %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %113 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %118 = OpConstantNull %int %_ptr_Uniform_float = OpTypePointer Uniform %float %int_1 = OpConstant %int 1 %uint_2 = OpConstant %uint 2 @@ -178,273 +175,273 @@ %65 = OpFAdd %v2float %64 %a_particlePos %66 = OpCompositeExtract %float %65 0 %67 = OpCompositeExtract %float %65 1 - %70 = OpCompositeConstruct %v4float %66 %67 %float_0 %float_1 - OpReturnValue %70 + %69 = OpCompositeConstruct %v4float %66 %67 %13 %float_1 + OpReturnValue %69 OpFunctionEnd - %vert_main = OpFunction %void None %71 - %74 = OpLabel - %76 = OpLoad %v2float %a_particlePos_1 - %77 = OpLoad %v2float %a_particleVel_1 - %78 = OpLoad %v2float %a_pos_1 - %75 = OpFunctionCall %v4float %vert_main_inner %76 %77 %78 - OpStore %value %75 + %vert_main = OpFunction %void None %70 + %73 = OpLabel + %75 = OpLoad %v2float %a_particlePos_1 + %76 = OpLoad %v2float %a_particleVel_1 + %77 = OpLoad %v2float %a_pos_1 + %74 = OpFunctionCall %v4float %vert_main_inner %75 %76 %77 + OpStore %value %74 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd -%frag_main_inner = OpFunction %v4float None %79 - %81 = OpLabel - OpReturnValue %82 +%frag_main_inner = OpFunction %v4float None %78 + %80 = OpLabel + OpReturnValue %81 OpFunctionEnd - %frag_main = OpFunction %void None %71 - %84 = OpLabel - %85 = OpFunctionCall %v4float %frag_main_inner - OpStore %value_1 %85 + %frag_main = OpFunction %void None %70 + %83 = OpLabel + %84 = OpFunctionCall %v4float %frag_main_inner + OpStore %value_1 %84 OpReturn OpFunctionEnd -%comp_main_inner = OpFunction %void None %86 +%comp_main_inner = OpFunction %void None %85 %gl_GlobalInvocationID = OpFunctionParameter %v3uint - %89 = OpLabel - %index = OpVariable %_ptr_Function_uint Function %93 + %88 = OpLabel + %index = OpVariable %_ptr_Function_uint Function %92 %vPos = OpVariable %_ptr_Function_v2float Function %63 %vVel = OpVariable %_ptr_Function_v2float Function %63 %cMass = OpVariable %_ptr_Function_v2float Function %63 %cVel = OpVariable %_ptr_Function_v2float Function %63 %colVel = OpVariable %_ptr_Function_v2float Function %63 - %cMassCount = OpVariable %_ptr_Function_int Function %118 - %cVelCount = OpVariable %_ptr_Function_int Function %118 + %cMassCount = OpVariable %_ptr_Function_int Function %113 + %cVelCount = OpVariable %_ptr_Function_int Function %113 %pos_0 = OpVariable %_ptr_Function_v2float Function %63 %vel = OpVariable %_ptr_Function_v2float Function %63 - %i = OpVariable %_ptr_Function_uint Function %93 - %90 = OpCompositeExtract %uint %gl_GlobalInvocationID 0 - OpStore %index %90 - %94 = OpLoad %uint %index - %95 = OpUGreaterThanEqual %bool %94 %uint_5 - OpSelectionMerge %97 None - OpBranchConditional %95 %98 %97 - %98 = OpLabel - OpReturn + %i = OpVariable %_ptr_Function_uint Function %92 + %89 = OpCompositeExtract %uint %gl_GlobalInvocationID 0 + OpStore %index %89 + %93 = OpLoad %uint %index + %94 = OpUGreaterThanEqual %bool %93 %uint_5 + OpSelectionMerge %96 None + OpBranchConditional %94 %97 %96 %97 = OpLabel - %100 = OpLoad %uint %index - %102 = OpAccessChain %_ptr_StorageBuffer_v2float %particlesA %uint_0 %100 %uint_0 - %103 = OpLoad %v2float %102 - OpStore %vPos %103 - %105 = OpLoad %uint %index - %107 = OpAccessChain %_ptr_StorageBuffer_v2float %particlesA %uint_0 %105 %uint_1 - %108 = OpLoad %v2float %107 - OpStore %vVel %108 - OpStore %cMass %110 - OpStore %cVel %110 - OpStore %colVel %110 - OpStore %cMassCount %int_0 - OpStore %cVelCount %int_0 - OpStore %i %uint_0 + OpReturn + %96 = OpLabel + %99 = OpLoad %uint %index + %101 = OpAccessChain %_ptr_StorageBuffer_v2float %particlesA %uint_0 %99 %uint_0 + %102 = OpLoad %v2float %101 + OpStore %vPos %102 + %104 = OpLoad %uint %index + %106 = OpAccessChain %_ptr_StorageBuffer_v2float %particlesA %uint_0 %104 %uint_1 + %107 = OpLoad %v2float %106 + OpStore %vVel %107 + OpStore %cMass %63 + OpStore %cVel %63 + OpStore %colVel %63 + OpStore %cMassCount %113 + OpStore %cVelCount %113 + OpStore %i %92 + OpBranch %120 + %120 = OpLabel + OpLoopMerge %121 %122 None OpBranch %123 %123 = OpLabel - OpLoopMerge %124 %125 None - OpBranch %126 - %126 = OpLabel - %128 = OpLoad %uint %i - %129 = OpULessThan %bool %128 %uint_5 - %127 = OpLogicalNot %bool %129 - OpSelectionMerge %130 None - OpBranchConditional %127 %131 %130 - %131 = OpLabel - OpBranch %124 - %130 = OpLabel - %132 = OpLoad %uint %i - %133 = OpLoad %uint %index - %134 = OpIEqual %bool %132 %133 - OpSelectionMerge %135 None - OpBranchConditional %134 %136 %135 - %136 = OpLabel - OpBranch %125 - %135 = OpLabel - %137 = OpLoad %uint %i - %138 = OpAccessChain %_ptr_StorageBuffer_v2float %particlesA %uint_0 %137 %uint_0 - %139 = OpLoad %v2float %138 - %140 = OpVectorShuffle %v2float %139 %139 0 1 - OpStore %pos_0 %140 - %141 = OpLoad %uint %i - %142 = OpAccessChain %_ptr_StorageBuffer_v2float %particlesA %uint_0 %141 %uint_1 - %143 = OpLoad %v2float %142 - %144 = OpVectorShuffle %v2float %143 %143 0 1 - OpStore %vel %144 - %146 = OpLoad %v2float %pos_0 - %147 = OpLoad %v2float %vPos - %145 = OpExtInst %float %37 Distance %146 %147 - %149 = OpAccessChain %_ptr_Uniform_float %params %uint_1 - %150 = OpLoad %float %149 - %151 = OpFOrdLessThan %bool %145 %150 - OpSelectionMerge %152 None - OpBranchConditional %151 %153 %152 - %153 = OpLabel - %154 = OpLoad %v2float %cMass - %155 = OpLoad %v2float %pos_0 - %156 = OpFAdd %v2float %154 %155 - OpStore %cMass %156 - %157 = OpLoad %int %cMassCount - %159 = OpIAdd %int %157 %int_1 - OpStore %cMassCount %159 - OpBranch %152 - %152 = OpLabel - %161 = OpLoad %v2float %pos_0 - %162 = OpLoad %v2float %vPos - %160 = OpExtInst %float %37 Distance %161 %162 - %164 = OpAccessChain %_ptr_Uniform_float %params %uint_2 - %165 = OpLoad %float %164 - %166 = OpFOrdLessThan %bool %160 %165 - OpSelectionMerge %167 None - OpBranchConditional %166 %168 %167 - %168 = OpLabel - %169 = OpLoad %v2float %colVel - %170 = OpLoad %v2float %pos_0 - %171 = OpLoad %v2float %vPos - %172 = OpFSub %v2float %170 %171 - %173 = OpFSub %v2float %169 %172 - OpStore %colVel %173 - OpBranch %167 - %167 = OpLabel - %175 = OpLoad %v2float %pos_0 - %176 = OpLoad %v2float %vPos - %174 = OpExtInst %float %37 Distance %175 %176 - %178 = OpAccessChain %_ptr_Uniform_float %params %uint_3 - %179 = OpLoad %float %178 - %180 = OpFOrdLessThan %bool %174 %179 - OpSelectionMerge %181 None - OpBranchConditional %180 %182 %181 - %182 = OpLabel - %183 = OpLoad %v2float %cVel - %184 = OpLoad %v2float %vel - %185 = OpFAdd %v2float %183 %184 - OpStore %cVel %185 - %186 = OpLoad %int %cVelCount - %187 = OpIAdd %int %186 %int_1 - OpStore %cVelCount %187 - OpBranch %181 - %181 = OpLabel - OpBranch %125 - %125 = OpLabel - %188 = OpLoad %uint %i - %189 = OpIAdd %uint %188 %uint_1 - OpStore %i %189 - OpBranch %123 - %124 = OpLabel - %190 = OpLoad %int %cMassCount - %191 = OpSGreaterThan %bool %190 %int_0 - OpSelectionMerge %192 None - OpBranchConditional %191 %193 %192 - %193 = OpLabel - %194 = OpLoad %v2float %cMass - %196 = OpLoad %int %cMassCount - %195 = OpConvertSToF %float %196 - %198 = OpLoad %int %cMassCount - %197 = OpConvertSToF %float %198 - %199 = OpCompositeConstruct %v2float %195 %197 - %200 = OpFDiv %v2float %194 %199 - %201 = OpLoad %v2float %vPos - %202 = OpFSub %v2float %200 %201 - OpStore %cMass %202 - OpBranch %192 - %192 = OpLabel - %203 = OpLoad %int %cVelCount - %204 = OpSGreaterThan %bool %203 %int_0 - OpSelectionMerge %205 None - OpBranchConditional %204 %206 %205 - %206 = OpLabel - %207 = OpLoad %v2float %cVel - %209 = OpLoad %int %cVelCount - %208 = OpConvertSToF %float %209 - %211 = OpLoad %int %cVelCount - %210 = OpConvertSToF %float %211 - %212 = OpCompositeConstruct %v2float %208 %210 - %213 = OpFDiv %v2float %207 %212 - OpStore %cVel %213 - OpBranch %205 - %205 = OpLabel - %214 = OpLoad %v2float %vVel - %215 = OpLoad %v2float %cMass - %217 = OpAccessChain %_ptr_Uniform_float %params %uint_4 - %218 = OpLoad %float %217 - %219 = OpVectorTimesScalar %v2float %215 %218 - %220 = OpFAdd %v2float %214 %219 - %221 = OpLoad %v2float %colVel - %222 = OpAccessChain %_ptr_Uniform_float %params %uint_5 - %223 = OpLoad %float %222 - %224 = OpVectorTimesScalar %v2float %221 %223 - %225 = OpFAdd %v2float %220 %224 - %226 = OpLoad %v2float %cVel - %228 = OpAccessChain %_ptr_Uniform_float %params %uint_6 - %229 = OpLoad %float %228 - %230 = OpVectorTimesScalar %v2float %226 %229 - %231 = OpFAdd %v2float %225 %230 - OpStore %vVel %231 + %125 = OpLoad %uint %i + %126 = OpULessThan %bool %125 %uint_5 + %124 = OpLogicalNot %bool %126 + OpSelectionMerge %127 None + OpBranchConditional %124 %128 %127 + %128 = OpLabel + OpBranch %121 + %127 = OpLabel + %129 = OpLoad %uint %i + %130 = OpLoad %uint %index + %131 = OpIEqual %bool %129 %130 + OpSelectionMerge %132 None + OpBranchConditional %131 %133 %132 + %133 = OpLabel + OpBranch %122 + %132 = OpLabel + %134 = OpLoad %uint %i + %135 = OpAccessChain %_ptr_StorageBuffer_v2float %particlesA %uint_0 %134 %uint_0 + %136 = OpLoad %v2float %135 + %137 = OpVectorShuffle %v2float %136 %136 0 1 + OpStore %pos_0 %137 + %138 = OpLoad %uint %i + %139 = OpAccessChain %_ptr_StorageBuffer_v2float %particlesA %uint_0 %138 %uint_1 + %140 = OpLoad %v2float %139 + %141 = OpVectorShuffle %v2float %140 %140 0 1 + OpStore %vel %141 + %143 = OpLoad %v2float %pos_0 + %144 = OpLoad %v2float %vPos + %142 = OpExtInst %float %37 Distance %143 %144 + %146 = OpAccessChain %_ptr_Uniform_float %params %uint_1 + %147 = OpLoad %float %146 + %148 = OpFOrdLessThan %bool %142 %147 + OpSelectionMerge %149 None + OpBranchConditional %148 %150 %149 + %150 = OpLabel + %151 = OpLoad %v2float %cMass + %152 = OpLoad %v2float %pos_0 + %153 = OpFAdd %v2float %151 %152 + OpStore %cMass %153 + %154 = OpLoad %int %cMassCount + %156 = OpIAdd %int %154 %int_1 + OpStore %cMassCount %156 + OpBranch %149 + %149 = OpLabel + %158 = OpLoad %v2float %pos_0 + %159 = OpLoad %v2float %vPos + %157 = OpExtInst %float %37 Distance %158 %159 + %161 = OpAccessChain %_ptr_Uniform_float %params %uint_2 + %162 = OpLoad %float %161 + %163 = OpFOrdLessThan %bool %157 %162 + OpSelectionMerge %164 None + OpBranchConditional %163 %165 %164 + %165 = OpLabel + %166 = OpLoad %v2float %colVel + %167 = OpLoad %v2float %pos_0 + %168 = OpLoad %v2float %vPos + %169 = OpFSub %v2float %167 %168 + %170 = OpFSub %v2float %166 %169 + OpStore %colVel %170 + OpBranch %164 + %164 = OpLabel + %172 = OpLoad %v2float %pos_0 + %173 = OpLoad %v2float %vPos + %171 = OpExtInst %float %37 Distance %172 %173 + %175 = OpAccessChain %_ptr_Uniform_float %params %uint_3 + %176 = OpLoad %float %175 + %177 = OpFOrdLessThan %bool %171 %176 + OpSelectionMerge %178 None + OpBranchConditional %177 %179 %178 + %179 = OpLabel + %180 = OpLoad %v2float %cVel + %181 = OpLoad %v2float %vel + %182 = OpFAdd %v2float %180 %181 + OpStore %cVel %182 + %183 = OpLoad %int %cVelCount + %184 = OpIAdd %int %183 %int_1 + OpStore %cVelCount %184 + OpBranch %178 + %178 = OpLabel + OpBranch %122 + %122 = OpLabel + %185 = OpLoad %uint %i + %186 = OpIAdd %uint %185 %uint_1 + OpStore %i %186 + OpBranch %120 + %121 = OpLabel + %187 = OpLoad %int %cMassCount + %188 = OpSGreaterThan %bool %187 %113 + OpSelectionMerge %189 None + OpBranchConditional %188 %190 %189 + %190 = OpLabel + %191 = OpLoad %v2float %cMass + %193 = OpLoad %int %cMassCount + %192 = OpConvertSToF %float %193 + %195 = OpLoad %int %cMassCount + %194 = OpConvertSToF %float %195 + %196 = OpCompositeConstruct %v2float %192 %194 + %197 = OpFDiv %v2float %191 %196 + %198 = OpLoad %v2float %vPos + %199 = OpFSub %v2float %197 %198 + OpStore %cMass %199 + OpBranch %189 + %189 = OpLabel + %200 = OpLoad %int %cVelCount + %201 = OpSGreaterThan %bool %200 %113 + OpSelectionMerge %202 None + OpBranchConditional %201 %203 %202 + %203 = OpLabel + %204 = OpLoad %v2float %cVel + %206 = OpLoad %int %cVelCount + %205 = OpConvertSToF %float %206 + %208 = OpLoad %int %cVelCount + %207 = OpConvertSToF %float %208 + %209 = OpCompositeConstruct %v2float %205 %207 + %210 = OpFDiv %v2float %204 %209 + OpStore %cVel %210 + OpBranch %202 + %202 = OpLabel + %211 = OpLoad %v2float %vVel + %212 = OpLoad %v2float %cMass + %214 = OpAccessChain %_ptr_Uniform_float %params %uint_4 + %215 = OpLoad %float %214 + %216 = OpVectorTimesScalar %v2float %212 %215 + %217 = OpFAdd %v2float %211 %216 + %218 = OpLoad %v2float %colVel + %219 = OpAccessChain %_ptr_Uniform_float %params %uint_5 + %220 = OpLoad %float %219 + %221 = OpVectorTimesScalar %v2float %218 %220 + %222 = OpFAdd %v2float %217 %221 + %223 = OpLoad %v2float %cVel + %225 = OpAccessChain %_ptr_Uniform_float %params %uint_6 + %226 = OpLoad %float %225 + %227 = OpVectorTimesScalar %v2float %223 %226 + %228 = OpFAdd %v2float %222 %227 + OpStore %vVel %228 + %230 = OpLoad %v2float %vVel + %229 = OpExtInst %v2float %37 Normalize %230 %233 = OpLoad %v2float %vVel - %232 = OpExtInst %v2float %37 Normalize %233 - %236 = OpLoad %v2float %vVel - %235 = OpExtInst %float %37 Length %236 - %234 = OpExtInst %float %37 NClamp %235 %float_0 %float_0_100000001 - %238 = OpVectorTimesScalar %v2float %232 %234 - OpStore %vVel %238 - %239 = OpLoad %v2float %vPos - %240 = OpLoad %v2float %vVel - %241 = OpAccessChain %_ptr_Uniform_float %params %uint_0 - %242 = OpLoad %float %241 - %243 = OpVectorTimesScalar %v2float %240 %242 - %244 = OpFAdd %v2float %239 %243 - OpStore %vPos %244 - %245 = OpAccessChain %_ptr_Function_float %vPos %uint_0 - %246 = OpLoad %float %245 - %248 = OpFOrdLessThan %bool %246 %float_n1 - OpSelectionMerge %249 None - OpBranchConditional %248 %250 %249 - %250 = OpLabel - %251 = OpAccessChain %_ptr_Function_float %vPos %uint_0 - OpStore %251 %float_1 - OpBranch %249 - %249 = OpLabel - %252 = OpAccessChain %_ptr_Function_float %vPos %uint_0 - %253 = OpLoad %float %252 - %254 = OpFOrdGreaterThan %bool %253 %float_1 - OpSelectionMerge %255 None - OpBranchConditional %254 %256 %255 - %256 = OpLabel - %257 = OpAccessChain %_ptr_Function_float %vPos %uint_0 - OpStore %257 %float_n1 - OpBranch %255 - %255 = OpLabel - %258 = OpAccessChain %_ptr_Function_float %vPos %uint_1 - %259 = OpLoad %float %258 - %260 = OpFOrdLessThan %bool %259 %float_n1 - OpSelectionMerge %261 None - OpBranchConditional %260 %262 %261 - %262 = OpLabel - %263 = OpAccessChain %_ptr_Function_float %vPos %uint_1 - OpStore %263 %float_1 - OpBranch %261 - %261 = OpLabel - %264 = OpAccessChain %_ptr_Function_float %vPos %uint_1 - %265 = OpLoad %float %264 - %266 = OpFOrdGreaterThan %bool %265 %float_1 - OpSelectionMerge %267 None - OpBranchConditional %266 %268 %267 - %268 = OpLabel - %269 = OpAccessChain %_ptr_Function_float %vPos %uint_1 - OpStore %269 %float_n1 - OpBranch %267 - %267 = OpLabel + %232 = OpExtInst %float %37 Length %233 + %231 = OpExtInst %float %37 NClamp %232 %13 %float_0_100000001 + %235 = OpVectorTimesScalar %v2float %229 %231 + OpStore %vVel %235 + %236 = OpLoad %v2float %vPos + %237 = OpLoad %v2float %vVel + %238 = OpAccessChain %_ptr_Uniform_float %params %uint_0 + %239 = OpLoad %float %238 + %240 = OpVectorTimesScalar %v2float %237 %239 + %241 = OpFAdd %v2float %236 %240 + OpStore %vPos %241 + %242 = OpAccessChain %_ptr_Function_float %vPos %uint_0 + %243 = OpLoad %float %242 + %245 = OpFOrdLessThan %bool %243 %float_n1 + OpSelectionMerge %246 None + OpBranchConditional %245 %247 %246 + %247 = OpLabel + %248 = OpAccessChain %_ptr_Function_float %vPos %uint_0 + OpStore %248 %float_1 + OpBranch %246 + %246 = OpLabel + %249 = OpAccessChain %_ptr_Function_float %vPos %uint_0 + %250 = OpLoad %float %249 + %251 = OpFOrdGreaterThan %bool %250 %float_1 + OpSelectionMerge %252 None + OpBranchConditional %251 %253 %252 + %253 = OpLabel + %254 = OpAccessChain %_ptr_Function_float %vPos %uint_0 + OpStore %254 %float_n1 + OpBranch %252 + %252 = OpLabel + %255 = OpAccessChain %_ptr_Function_float %vPos %uint_1 + %256 = OpLoad %float %255 + %257 = OpFOrdLessThan %bool %256 %float_n1 + OpSelectionMerge %258 None + OpBranchConditional %257 %259 %258 + %259 = OpLabel + %260 = OpAccessChain %_ptr_Function_float %vPos %uint_1 + OpStore %260 %float_1 + OpBranch %258 + %258 = OpLabel + %261 = OpAccessChain %_ptr_Function_float %vPos %uint_1 + %262 = OpLoad %float %261 + %263 = OpFOrdGreaterThan %bool %262 %float_1 + OpSelectionMerge %264 None + OpBranchConditional %263 %265 %264 + %265 = OpLabel + %266 = OpAccessChain %_ptr_Function_float %vPos %uint_1 + OpStore %266 %float_n1 + OpBranch %264 + %264 = OpLabel + %267 = OpLoad %uint %index + %268 = OpAccessChain %_ptr_StorageBuffer_v2float %particlesB %uint_0 %267 %uint_0 + %269 = OpLoad %v2float %vPos + OpStore %268 %269 %270 = OpLoad %uint %index - %271 = OpAccessChain %_ptr_StorageBuffer_v2float %particlesB %uint_0 %270 %uint_0 - %272 = OpLoad %v2float %vPos + %271 = OpAccessChain %_ptr_StorageBuffer_v2float %particlesB %uint_0 %270 %uint_1 + %272 = OpLoad %v2float %vVel OpStore %271 %272 - %273 = OpLoad %uint %index - %274 = OpAccessChain %_ptr_StorageBuffer_v2float %particlesB %uint_0 %273 %uint_1 - %275 = OpLoad %v2float %vVel - OpStore %274 %275 OpReturn OpFunctionEnd - %comp_main = OpFunction %void None %71 - %277 = OpLabel - %279 = OpLoad %v3uint %gl_GlobalInvocationID_1 - %278 = OpFunctionCall %void %comp_main_inner %279 + %comp_main = OpFunction %void None %70 + %274 = OpLabel + %276 = OpLoad %v3uint %gl_GlobalInvocationID_1 + %275 = OpFunctionCall %void %comp_main_inner %276 OpReturn OpFunctionEnd diff --git a/test/tint/samples/simple_vertex.spvasm.expected.spvasm b/test/tint/samples/simple_vertex.spvasm.expected.spvasm index 0a7c17bbc0..29cf03454f 100644 --- a/test/tint/samples/simple_vertex.spvasm.expected.spvasm +++ b/test/tint/samples/simple_vertex.spvasm.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 29 +; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -29,28 +29,26 @@ %gl_Position = OpVariable %_ptr_Private_v4float Private %5 %void = OpTypeVoid %11 = OpTypeFunction %void - %float_0 = OpConstant %float 0 - %16 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %main_out = OpTypeStruct %v4float - %17 = OpTypeFunction %main_out + %15 = OpTypeFunction %main_out %float_1 = OpConstant %float 1 %main_1 = OpFunction %void None %11 %14 = OpLabel - OpStore %gl_Position %16 + OpStore %gl_Position %5 OpReturn OpFunctionEnd - %main_inner = OpFunction %main_out None %17 - %20 = OpLabel - %21 = OpFunctionCall %void %main_1 - %22 = OpLoad %v4float %gl_Position - %23 = OpCompositeConstruct %main_out %22 - OpReturnValue %23 + %main_inner = OpFunction %main_out None %15 + %18 = OpLabel + %19 = OpFunctionCall %void %main_1 + %20 = OpLoad %v4float %gl_Position + %21 = OpCompositeConstruct %main_out %20 + OpReturnValue %21 OpFunctionEnd %main = OpFunction %void None %11 - %25 = OpLabel - %26 = OpFunctionCall %main_out %main_inner - %27 = OpCompositeExtract %v4float %26 0 - OpStore %gl_Position_1 %27 + %23 = OpLabel + %24 = OpFunctionCall %main_out %main_inner + %25 = OpCompositeExtract %v4float %24 0 + OpStore %gl_Position_1 %25 OpStore %vertex_point_size %float_1 OpReturn OpFunctionEnd diff --git a/test/tint/samples/triangle.wgsl.expected.spvasm b/test/tint/samples/triangle.wgsl.expected.spvasm index 1816286e02..e72e5aa052 100644 --- a/test/tint/samples/triangle.wgsl.expected.spvasm +++ b/test/tint/samples/triangle.wgsl.expected.spvasm @@ -64,7 +64,7 @@ %32 = OpLoad %v2float %31 %33 = OpCompositeExtract %float %32 0 %34 = OpCompositeExtract %float %32 1 - %36 = OpCompositeConstruct %v4float %33 %34 %float_0 %float_1 + %36 = OpCompositeConstruct %v4float %33 %34 %11 %float_1 OpReturnValue %36 OpFunctionEnd %vtx_main = OpFunction %void None %37 diff --git a/test/tint/shader_io/fragment_input_builtins.wgsl.expected.spvasm b/test/tint/shader_io/fragment_input_builtins.wgsl.expected.spvasm index daf288b9b5..22599f1680 100644 --- a/test/tint/shader_io/fragment_input_builtins.wgsl.expected.spvasm +++ b/test/tint/shader_io/fragment_input_builtins.wgsl.expected.spvasm @@ -41,7 +41,7 @@ %15 = OpTypeFunction %void %v4float %bool %uint %uint %26 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %34 = OpConstantNull %int %main_inner = OpFunction %void None %15 %position = OpFunctionParameter %v4float %front_facing = OpFunctionParameter %bool @@ -61,7 +61,7 @@ %30 = OpLoad %v4float %position_1 %31 = OpLoad %bool %front_facing_1 %32 = OpLoad %uint %sample_index_1 - %35 = OpAccessChain %_ptr_Input_uint %sample_mask_1 %int_0 + %35 = OpAccessChain %_ptr_Input_uint %sample_mask_1 %34 %36 = OpLoad %uint %35 %29 = OpFunctionCall %void %main_inner %30 %31 %32 %36 OpReturn diff --git a/test/tint/shader_io/fragment_input_builtins_struct.wgsl.expected.spvasm b/test/tint/shader_io/fragment_input_builtins_struct.wgsl.expected.spvasm index a826ffb185..b38c244ab3 100644 --- a/test/tint/shader_io/fragment_input_builtins_struct.wgsl.expected.spvasm +++ b/test/tint/shader_io/fragment_input_builtins_struct.wgsl.expected.spvasm @@ -48,7 +48,7 @@ %15 = OpTypeFunction %void %FragmentInputs %28 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %36 = OpConstantNull %int %main_inner = OpFunction %void None %15 %inputs = OpFunctionParameter %FragmentInputs %20 = OpLabel @@ -69,7 +69,7 @@ %32 = OpLoad %v4float %position_1 %33 = OpLoad %bool %front_facing_1 %34 = OpLoad %uint %sample_index_1 - %37 = OpAccessChain %_ptr_Input_uint %sample_mask_1 %int_0 + %37 = OpAccessChain %_ptr_Input_uint %sample_mask_1 %36 %38 = OpLoad %uint %37 %39 = OpCompositeConstruct %FragmentInputs %32 %33 %34 %38 %31 = OpFunctionCall %void %main_inner %39 diff --git a/test/tint/shader_io/fragment_input_mixed.wgsl.expected.spvasm b/test/tint/shader_io/fragment_input_mixed.wgsl.expected.spvasm index d312bcf427..2f87413dac 100644 --- a/test/tint/shader_io/fragment_input_mixed.wgsl.expected.spvasm +++ b/test/tint/shader_io/fragment_input_mixed.wgsl.expected.spvasm @@ -71,7 +71,7 @@ %FragmentInputs1 = OpTypeStruct %v4float %uint %22 = OpTypeFunction %void %FragmentInputs0 %bool %uint %uint %FragmentInputs1 %float %41 = OpTypeFunction %void - %int_0 = OpConstant %int 0 + %52 = OpConstantNull %int %main_inner = OpFunction %void None %22 %inputs0 = OpFunctionParameter %FragmentInputs0 %front_facing = OpFunctionParameter %bool @@ -101,7 +101,7 @@ %49 = OpLoad %uint %loc1_1 %50 = OpLoad %uint %sample_index_1 %51 = OpLoad %v4float %loc3_1 - %53 = OpAccessChain %_ptr_Input_uint %sample_mask_1 %int_0 + %53 = OpAccessChain %_ptr_Input_uint %sample_mask_1 %52 %54 = OpLoad %uint %53 %55 = OpCompositeConstruct %FragmentInputs1 %51 %54 %56 = OpLoad %float %loc2_1 diff --git a/test/tint/shader_io/fragment_output_builtins.wgsl.expected.spvasm b/test/tint/shader_io/fragment_output_builtins.wgsl.expected.spvasm index 7eb37e0c66..02663d13b6 100644 --- a/test/tint/shader_io/fragment_output_builtins.wgsl.expected.spvasm +++ b/test/tint/shader_io/fragment_output_builtins.wgsl.expected.spvasm @@ -35,7 +35,7 @@ %15 = OpTypeFunction %void %20 = OpTypeFunction %uint %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %27 = OpConstantNull %int %_ptr_Output_uint = OpTypePointer Output %uint %main1_inner = OpFunction %float None %11 %13 = OpLabel @@ -54,7 +54,7 @@ %main2 = OpFunction %void None %15 %24 = OpLabel %25 = OpFunctionCall %uint %main2_inner - %29 = OpAccessChain %_ptr_Output_uint %value_1 %int_0 + %29 = OpAccessChain %_ptr_Output_uint %value_1 %27 OpStore %29 %25 OpReturn OpFunctionEnd diff --git a/test/tint/shader_io/fragment_output_builtins_struct.wgsl.expected.spvasm b/test/tint/shader_io/fragment_output_builtins_struct.wgsl.expected.spvasm index b43155135e..6850a788fb 100644 --- a/test/tint/shader_io/fragment_output_builtins_struct.wgsl.expected.spvasm +++ b/test/tint/shader_io/fragment_output_builtins_struct.wgsl.expected.spvasm @@ -37,7 +37,7 @@ %void = OpTypeVoid %17 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %24 = OpConstantNull %int %_ptr_Output_uint = OpTypePointer Output %uint %main_inner = OpFunction %FragmentOutputs None %11 %14 = OpLabel @@ -48,7 +48,7 @@ %21 = OpFunctionCall %FragmentOutputs %main_inner %22 = OpCompositeExtract %float %21 0 OpStore %frag_depth_1 %22 - %26 = OpAccessChain %_ptr_Output_uint %sample_mask_1 %int_0 + %26 = OpAccessChain %_ptr_Output_uint %sample_mask_1 %24 %27 = OpCompositeExtract %uint %21 1 OpStore %26 %27 OpReturn diff --git a/test/tint/shader_io/fragment_output_mixed.wgsl.expected.spvasm b/test/tint/shader_io/fragment_output_mixed.wgsl.expected.spvasm index 4002fe6fc3..897421e0e1 100644 --- a/test/tint/shader_io/fragment_output_mixed.wgsl.expected.spvasm +++ b/test/tint/shader_io/fragment_output_mixed.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 48 +; Bound: 47 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -70,7 +70,6 @@ %34 = OpConstantComposite %FragmentOutputs %int_1 %float_2 %uint_1 %float_1 %uint_2 %33 %void = OpTypeVoid %35 = OpTypeFunction %void - %int_0 = OpConstant %int 0 %main_inner = OpFunction %FragmentOutputs None %23 %26 = OpLabel OpReturnValue %34 @@ -86,10 +85,10 @@ OpStore %loc1_1 %42 %43 = OpCompositeExtract %float %39 3 OpStore %loc2_1 %43 - %45 = OpAccessChain %_ptr_Output_uint %sample_mask_1 %int_0 - %46 = OpCompositeExtract %uint %39 4 - OpStore %45 %46 - %47 = OpCompositeExtract %v4float %39 5 - OpStore %loc3_1 %47 + %44 = OpAccessChain %_ptr_Output_uint %sample_mask_1 %4 + %45 = OpCompositeExtract %uint %39 4 + OpStore %44 %45 + %46 = OpCompositeExtract %v4float %39 5 + OpStore %loc3_1 %46 OpReturn OpFunctionEnd diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_body.wgsl.expected.spvasm b/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_body.wgsl.expected.spvasm index 60f11df715..de7d64cfb8 100644 --- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_body.wgsl.expected.spvasm +++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_body.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 44 +; Bound: 43 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -41,9 +41,8 @@ %OuterS = OpTypeStruct %_arr_InnerS_uint_8 %_ptr_Function_OuterS = OpTypePointer Function %OuterS %19 = OpConstantNull %OuterS - %int_0 = OpConstant %int 0 + %20 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %23 = OpConstantNull %int %int_4 = OpConstant %int 4 %bool = OpTypeBool %uint_0 = OpConstant %uint 0 @@ -53,32 +52,32 @@ %8 = OpLabel %v = OpVariable %_ptr_Function_InnerS Function %13 %s1 = OpVariable %_ptr_Function_OuterS Function %19 - %i = OpVariable %_ptr_Function_int Function %23 - OpStore %i %int_0 - OpBranch %24 - %24 = OpLabel - OpLoopMerge %25 %26 None - OpBranch %27 - %27 = OpLabel - %29 = OpLoad %int %i - %31 = OpSLessThan %bool %29 %int_4 - %28 = OpLogicalNot %bool %31 - OpSelectionMerge %33 None - OpBranchConditional %28 %34 %33 - %34 = OpLabel - OpBranch %25 - %33 = OpLabel - %37 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 - %38 = OpLoad %uint %37 - %39 = OpAccessChain %_ptr_Function_InnerS %s1 %uint_0 %38 - %40 = OpLoad %InnerS %v - OpStore %39 %40 + %i = OpVariable %_ptr_Function_int Function %20 + OpStore %i %20 + OpBranch %23 + %23 = OpLabel + OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel - %41 = OpLoad %int %i - %43 = OpIAdd %int %41 %int_1 - OpStore %i %43 + %28 = OpLoad %int %i + %30 = OpSLessThan %bool %28 %int_4 + %27 = OpLogicalNot %bool %30 + OpSelectionMerge %32 None + OpBranchConditional %27 %33 %32 + %33 = OpLabel OpBranch %24 + %32 = OpLabel + %36 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 + %37 = OpLoad %uint %36 + %38 = OpAccessChain %_ptr_Function_InnerS %s1 %uint_0 %37 + %39 = OpLoad %InnerS %v + OpStore %38 %39 + OpBranch %25 %25 = OpLabel + %40 = OpLoad %int %i + %42 = OpIAdd %int %40 %int_1 + OpStore %i %42 + OpBranch %23 + %24 = OpLabel OpReturn OpFunctionEnd diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_continuing.wgsl.expected.spvasm b/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_continuing.wgsl.expected.spvasm index 223d6261b9..47cbb056cc 100644 --- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_continuing.wgsl.expected.spvasm +++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_continuing.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 44 +; Bound: 43 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -41,9 +41,8 @@ %OuterS = OpTypeStruct %_arr_InnerS_uint_8 %_ptr_Function_OuterS = OpTypePointer Function %OuterS %19 = OpConstantNull %OuterS - %int_0 = OpConstant %int 0 + %20 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %23 = OpConstantNull %int %int_4 = OpConstant %int 4 %bool = OpTypeBool %int_1 = OpConstant %int 1 @@ -53,32 +52,32 @@ %8 = OpLabel %v = OpVariable %_ptr_Function_InnerS Function %13 %s1 = OpVariable %_ptr_Function_OuterS Function %19 - %i = OpVariable %_ptr_Function_int Function %23 - OpStore %i %int_0 - OpBranch %24 - %24 = OpLabel - OpLoopMerge %25 %26 None - OpBranch %27 - %27 = OpLabel - %29 = OpLoad %int %i - %31 = OpSLessThan %bool %29 %int_4 - %28 = OpLogicalNot %bool %31 - OpSelectionMerge %33 None - OpBranchConditional %28 %34 %33 - %34 = OpLabel - OpBranch %25 - %33 = OpLabel - %35 = OpLoad %int %i - %37 = OpIAdd %int %35 %int_1 - OpStore %i %37 + %i = OpVariable %_ptr_Function_int Function %20 + OpStore %i %20 + OpBranch %23 + %23 = OpLabel + OpLoopMerge %24 %25 None OpBranch %26 %26 = OpLabel - %40 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 - %41 = OpLoad %uint %40 - %42 = OpAccessChain %_ptr_Function_InnerS %s1 %uint_0 %41 - %43 = OpLoad %InnerS %v - OpStore %42 %43 + %28 = OpLoad %int %i + %30 = OpSLessThan %bool %28 %int_4 + %27 = OpLogicalNot %bool %30 + OpSelectionMerge %32 None + OpBranchConditional %27 %33 %32 + %33 = OpLabel OpBranch %24 + %32 = OpLabel + %34 = OpLoad %int %i + %36 = OpIAdd %int %34 %int_1 + OpStore %i %36 + OpBranch %25 %25 = OpLabel + %39 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 + %40 = OpLoad %uint %39 + %41 = OpAccessChain %_ptr_Function_InnerS %s1 %uint_0 %40 + %42 = OpLoad %InnerS %v + OpStore %41 %42 + OpBranch %23 + %24 = OpLabel OpReturn OpFunctionEnd diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_init.wgsl.expected.spvasm b/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_init.wgsl.expected.spvasm index ccdfdf38b6..e3e61dd652 100644 --- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_init.wgsl.expected.spvasm +++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_init.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 44 +; Bound: 43 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -41,9 +41,8 @@ %OuterS = OpTypeStruct %_arr_InnerS_uint_8 %_ptr_Function_OuterS = OpTypePointer Function %OuterS %19 = OpConstantNull %OuterS - %int_0 = OpConstant %int 0 + %20 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %23 = OpConstantNull %int %uint_0 = OpConstant %uint 0 %_ptr_Uniform_uint = OpTypePointer Uniform %uint %int_4 = OpConstant %int 4 @@ -53,32 +52,32 @@ %8 = OpLabel %v = OpVariable %_ptr_Function_InnerS Function %13 %s1 = OpVariable %_ptr_Function_OuterS Function %19 - %i = OpVariable %_ptr_Function_int Function %23 - OpStore %i %int_0 - %26 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 - %27 = OpLoad %uint %26 - %28 = OpAccessChain %_ptr_Function_InnerS %s1 %uint_0 %27 - %29 = OpLoad %InnerS %v - OpStore %28 %29 - OpBranch %30 - %30 = OpLabel - OpLoopMerge %31 %32 None - OpBranch %33 - %33 = OpLabel - %35 = OpLoad %int %i - %37 = OpSLessThan %bool %35 %int_4 - %34 = OpLogicalNot %bool %37 - OpSelectionMerge %39 None - OpBranchConditional %34 %40 %39 - %40 = OpLabel - OpBranch %31 - %39 = OpLabel + %i = OpVariable %_ptr_Function_int Function %20 + OpStore %i %20 + %25 = OpAccessChain %_ptr_Uniform_uint %uniforms %uint_0 + %26 = OpLoad %uint %25 + %27 = OpAccessChain %_ptr_Function_InnerS %s1 %uint_0 %26 + %28 = OpLoad %InnerS %v + OpStore %27 %28 + OpBranch %29 + %29 = OpLabel + OpLoopMerge %30 %31 None OpBranch %32 %32 = OpLabel - %41 = OpLoad %int %i - %43 = OpIAdd %int %41 %int_1 - OpStore %i %43 + %34 = OpLoad %int %i + %36 = OpSLessThan %bool %34 %int_4 + %33 = OpLogicalNot %bool %36 + OpSelectionMerge %38 None + OpBranchConditional %33 %39 %38 + %39 = OpLabel OpBranch %30 + %38 = OpLabel + OpBranch %31 %31 = OpLabel + %40 = OpLoad %int %i + %42 = OpIAdd %int %40 %int_1 + OpStore %i %42 + OpBranch %29 + %30 = OpLabel OpReturn OpFunctionEnd diff --git a/test/tint/statements/compound_assign/divide_by_zero.wgsl.expected.spvasm b/test/tint/statements/compound_assign/divide_by_zero.wgsl.expected.spvasm index 45e0f0f044..c5bc009db6 100644 --- a/test/tint/statements/compound_assign/divide_by_zero.wgsl.expected.spvasm +++ b/test/tint/statements/compound_assign/divide_by_zero.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 37 +; Bound: 35 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -23,8 +23,6 @@ %void = OpTypeVoid %9 = OpTypeFunction %void %13 = OpTypeFunction %void %int - %int_0 = OpConstant %int 0 - %float_0 = OpConstant %float 0 %unused_entry_point = OpFunction %void None %9 %12 = OpLabel OpReturn @@ -33,30 +31,30 @@ %maybe_zero = OpFunctionParameter %int %16 = OpLabel %17 = OpLoad %int %a - %19 = OpSDiv %int %17 %int_0 - OpStore %a %19 - %20 = OpLoad %int %a - %21 = OpSMod %int %20 %int_0 - OpStore %a %21 - %22 = OpLoad %int %a - %23 = OpSDiv %int %22 %maybe_zero - OpStore %a %23 - %24 = OpLoad %int %a - %25 = OpSMod %int %24 %maybe_zero - OpStore %a %25 - %26 = OpLoad %float %b - %28 = OpFDiv %float %26 %float_0 + %18 = OpSDiv %int %17 %4 + OpStore %a %18 + %19 = OpLoad %int %a + %20 = OpSMod %int %19 %4 + OpStore %a %20 + %21 = OpLoad %int %a + %22 = OpSDiv %int %21 %maybe_zero + OpStore %a %22 + %23 = OpLoad %int %a + %24 = OpSMod %int %23 %maybe_zero + OpStore %a %24 + %25 = OpLoad %float %b + %26 = OpFDiv %float %25 %8 + OpStore %b %26 + %27 = OpLoad %float %b + %28 = OpFRem %float %27 %8 OpStore %b %28 %29 = OpLoad %float %b - %30 = OpFRem %float %29 %float_0 - OpStore %b %30 - %31 = OpLoad %float %b - %32 = OpConvertSToF %float %maybe_zero - %33 = OpFDiv %float %31 %32 - OpStore %b %33 - %34 = OpLoad %float %b - %35 = OpConvertSToF %float %maybe_zero - %36 = OpFRem %float %34 %35 - OpStore %b %36 + %30 = OpConvertSToF %float %maybe_zero + %31 = OpFDiv %float %29 %30 + OpStore %b %31 + %32 = OpLoad %float %b + %33 = OpConvertSToF %float %maybe_zero + %34 = OpFRem %float %32 %33 + OpStore %b %34 OpReturn OpFunctionEnd diff --git a/test/tint/statements/decrement/complex.wgsl.expected.spvasm b/test/tint/statements/decrement/complex.wgsl.expected.spvasm index 7798efe386..41b2a734ab 100644 --- a/test/tint/statements/decrement/complex.wgsl.expected.spvasm +++ b/test/tint/statements/decrement/complex.wgsl.expected.spvasm @@ -49,7 +49,7 @@ %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %int_4 = OpConstant %int 4 - %int_0 = OpConstant %int 0 + %44 = OpConstantNull %int %uint_0 = OpConstant %uint 0 %_ptr_StorageBuffer_int = OpTypePointer StorageBuffer %int %uint_10 = OpConstant %uint 10 @@ -91,7 +91,7 @@ %42 = OpLoad %uint %v %43 = OpISub %uint %42 %uint_1 OpStore %v %43 - OpReturnValue %int_0 + OpReturnValue %44 OpFunctionEnd %idx6 = OpFunction %int None %18 %46 = OpLabel diff --git a/test/tint/statements/decrement/function.wgsl.expected.spvasm b/test/tint/statements/decrement/function.wgsl.expected.spvasm index 1eec1fa720..6fe20e9bc0 100644 --- a/test/tint/statements/decrement/function.wgsl.expected.spvasm +++ b/test/tint/statements/decrement/function.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 15 +; Bound: 14 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -13,9 +13,8 @@ %void = OpTypeVoid %1 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %8 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %11 = OpConstantNull %int %int_1 = OpConstant %int 1 %unused_entry_point = OpFunction %void None %1 %4 = OpLabel @@ -23,10 +22,10 @@ OpFunctionEnd %main = OpFunction %void None %1 %6 = OpLabel - %i = OpVariable %_ptr_Function_int Function %11 - OpStore %i %int_0 - %12 = OpLoad %int %i - %14 = OpISub %int %12 %int_1 - OpStore %i %14 + %i = OpVariable %_ptr_Function_int Function %8 + OpStore %i %8 + %11 = OpLoad %int %i + %13 = OpISub %int %11 %int_1 + OpStore %i %13 OpReturn OpFunctionEnd diff --git a/test/tint/statements/decrement/private.wgsl.expected.spvasm b/test/tint/statements/decrement/private.wgsl.expected.spvasm index 1514ee9241..a28b357653 100644 --- a/test/tint/statements/decrement/private.wgsl.expected.spvasm +++ b/test/tint/statements/decrement/private.wgsl.expected.spvasm @@ -11,9 +11,9 @@ OpName %unused_entry_point "unused_entry_point" OpName %main "main" %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %2 = OpConstantNull %int %_ptr_Private_int = OpTypePointer Private %int - %i = OpVariable %_ptr_Private_int Private %int_0 + %i = OpVariable %_ptr_Private_int Private %2 %void = OpTypeVoid %5 = OpTypeFunction %void %int_1 = OpConstant %int 1 diff --git a/test/tint/statements/for/basic.wgsl.expected.spvasm b/test/tint/statements/for/basic.wgsl.expected.spvasm index b537e54899..c7e0808f90 100644 --- a/test/tint/statements/for/basic.wgsl.expected.spvasm +++ b/test/tint/statements/for/basic.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 29 +; Bound: 28 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -14,9 +14,8 @@ %void = OpTypeVoid %1 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %10 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %13 = OpConstantNull %int %int_5 = OpConstant %int 5 %bool = OpTypeBool %int_1 = OpConstant %int 1 @@ -30,28 +29,28 @@ OpFunctionEnd %f = OpFunction %void None %1 %8 = OpLabel - %i = OpVariable %_ptr_Function_int Function %13 - OpStore %i %int_0 - OpBranch %14 - %14 = OpLabel - OpLoopMerge %15 %16 None - OpBranch %17 - %17 = OpLabel - %19 = OpLoad %int %i - %21 = OpSLessThan %bool %19 %int_5 - %18 = OpLogicalNot %bool %21 - OpSelectionMerge %23 None - OpBranchConditional %18 %24 %23 - %24 = OpLabel - OpBranch %15 - %23 = OpLabel - %25 = OpFunctionCall %void %some_loop_body + %i = OpVariable %_ptr_Function_int Function %10 + OpStore %i %10 + OpBranch %13 + %13 = OpLabel + OpLoopMerge %14 %15 None OpBranch %16 %16 = OpLabel - %26 = OpLoad %int %i - %28 = OpIAdd %int %26 %int_1 - OpStore %i %28 + %18 = OpLoad %int %i + %20 = OpSLessThan %bool %18 %int_5 + %17 = OpLogicalNot %bool %20 + OpSelectionMerge %22 None + OpBranchConditional %17 %23 %22 + %23 = OpLabel OpBranch %14 + %22 = OpLabel + %24 = OpFunctionCall %void %some_loop_body + OpBranch %15 %15 = OpLabel + %25 = OpLoad %int %i + %27 = OpIAdd %int %25 %int_1 + OpStore %i %27 + OpBranch %13 + %14 = OpLabel OpReturn OpFunctionEnd diff --git a/test/tint/statements/for/complex.wgsl.expected.spvasm b/test/tint/statements/for/complex.wgsl.expected.spvasm index 725edbf6ee..2c41cb0607 100644 --- a/test/tint/statements/for/complex.wgsl.expected.spvasm +++ b/test/tint/statements/for/complex.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 39 +; Bound: 38 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -17,7 +17,6 @@ %int = OpTypeInt 32 1 %_ptr_Function_int = OpTypePointer Function %int %12 = OpConstantNull %int - %int_0 = OpConstant %int 0 %int_5 = OpConstant %int 5 %bool = OpTypeBool %int_10 = OpConstant %int 10 @@ -35,38 +34,38 @@ %8 = OpLabel %j = OpVariable %_ptr_Function_int Function %12 %i = OpVariable %_ptr_Function_int Function %12 - OpStore %i %int_0 - OpBranch %15 - %15 = OpLabel - OpLoopMerge %16 %17 None - OpBranch %18 - %18 = OpLabel - %20 = OpLoad %int %i - %22 = OpSLessThan %bool %20 %int_5 - OpSelectionMerge %24 None - OpBranchConditional %22 %25 %24 - %25 = OpLabel - %26 = OpLoad %int %j - %28 = OpSLessThan %bool %26 %int_10 - OpBranch %24 - %24 = OpLabel - %29 = OpPhi %bool %22 %18 %28 %25 - %19 = OpLogicalNot %bool %29 - OpSelectionMerge %30 None - OpBranchConditional %19 %31 %30 - %31 = OpLabel - OpBranch %16 - %30 = OpLabel - %32 = OpFunctionCall %void %some_loop_body - %33 = OpLoad %int %i - %35 = OpIMul %int %33 %int_30 - OpStore %j %35 + OpStore %i %12 + OpBranch %14 + %14 = OpLabel + OpLoopMerge %15 %16 None OpBranch %17 %17 = OpLabel - %36 = OpLoad %int %i - %38 = OpIAdd %int %36 %int_1 - OpStore %i %38 + %19 = OpLoad %int %i + %21 = OpSLessThan %bool %19 %int_5 + OpSelectionMerge %23 None + OpBranchConditional %21 %24 %23 + %24 = OpLabel + %25 = OpLoad %int %j + %27 = OpSLessThan %bool %25 %int_10 + OpBranch %23 + %23 = OpLabel + %28 = OpPhi %bool %21 %17 %27 %24 + %18 = OpLogicalNot %bool %28 + OpSelectionMerge %29 None + OpBranchConditional %18 %30 %29 + %30 = OpLabel OpBranch %15 + %29 = OpLabel + %31 = OpFunctionCall %void %some_loop_body + %32 = OpLoad %int %i + %34 = OpIMul %int %32 %int_30 + OpStore %j %34 + OpBranch %16 %16 = OpLabel + %35 = OpLoad %int %i + %37 = OpIAdd %int %35 %int_1 + OpStore %i %37 + OpBranch %14 + %15 = OpLabel OpReturn OpFunctionEnd diff --git a/test/tint/statements/for/condition/array_ctor.wgsl.expected.spvasm b/test/tint/statements/for/condition/array_ctor.wgsl.expected.spvasm index b86a19fc5f..6f00eaece9 100644 --- a/test/tint/statements/for/condition/array_ctor.wgsl.expected.spvasm +++ b/test/tint/statements/for/condition/array_ctor.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 28 +; Bound: 27 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -21,7 +21,6 @@ %_arr_int_uint_1 = OpTypeArray %int %uint_1 %int_1 = OpConstant %int 1 %21 = OpConstantComposite %_arr_int_uint_1 %int_1 - %int_0 = OpConstant %int 0 %bool = OpTypeBool %unused_entry_point = OpFunction %void None %1 %4 = OpLabel @@ -36,14 +35,14 @@ OpBranch %14 %14 = OpLabel %16 = OpLoad %int %i - %23 = OpCompositeExtract %int %21 0 - %24 = OpSLessThan %bool %16 %23 - %15 = OpLogicalNot %bool %24 - OpSelectionMerge %26 None - OpBranchConditional %15 %27 %26 - %27 = OpLabel - OpBranch %12 + %22 = OpCompositeExtract %int %21 0 + %23 = OpSLessThan %bool %16 %22 + %15 = OpLogicalNot %bool %23 + OpSelectionMerge %25 None + OpBranchConditional %15 %26 %25 %26 = OpLabel + OpBranch %12 + %25 = OpLabel OpBranch %13 %13 = OpLabel OpBranch %11 diff --git a/test/tint/statements/for/continuing/array_ctor.wgsl.expected.spvasm b/test/tint/statements/for/continuing/array_ctor.wgsl.expected.spvasm index 85841095ed..1109a6165e 100644 --- a/test/tint/statements/for/continuing/array_ctor.wgsl.expected.spvasm +++ b/test/tint/statements/for/continuing/array_ctor.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 29 +; Bound: 28 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -17,13 +17,12 @@ %_ptr_Function_int = OpTypePointer Function %int %10 = OpConstantNull %int %bool = OpTypeBool - %false = OpConstantFalse %bool + %17 = OpConstantNull %bool %uint = OpTypeInt 32 0 %uint_1 = OpConstant %uint 1 %_arr_int_uint_1 = OpTypeArray %int %uint_1 %int_1 = OpConstant %int 1 %25 = OpConstantComposite %_arr_int_uint_1 %int_1 - %int_0 = OpConstant %int 0 %unused_entry_point = OpFunction %void None %1 %4 = OpLabel OpReturn @@ -36,7 +35,7 @@ OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel - %15 = OpLogicalNot %bool %false + %15 = OpLogicalNot %bool %17 OpSelectionMerge %18 None OpBranchConditional %15 %19 %18 %19 = OpLabel @@ -45,9 +44,9 @@ OpBranch %13 %13 = OpLabel %20 = OpLoad %int %i - %27 = OpCompositeExtract %int %25 0 - %28 = OpIAdd %int %20 %27 - OpStore %i %28 + %26 = OpCompositeExtract %int %25 0 + %27 = OpIAdd %int %20 %26 + OpStore %i %27 OpBranch %11 %12 = OpLabel OpReturn diff --git a/test/tint/statements/for/continuing/basic.wgsl.expected.spvasm b/test/tint/statements/for/continuing/basic.wgsl.expected.spvasm index a7378a0bdf..9c2bfcb5a2 100644 --- a/test/tint/statements/for/continuing/basic.wgsl.expected.spvasm +++ b/test/tint/statements/for/continuing/basic.wgsl.expected.spvasm @@ -16,7 +16,7 @@ %_ptr_Function_int = OpTypePointer Function %int %10 = OpConstantNull %int %bool = OpTypeBool - %false = OpConstantFalse %bool + %17 = OpConstantNull %bool %int_1 = OpConstant %int 1 %unused_entry_point = OpFunction %void None %1 %4 = OpLabel @@ -30,7 +30,7 @@ OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel - %15 = OpLogicalNot %bool %false + %15 = OpLogicalNot %bool %17 OpSelectionMerge %18 None OpBranchConditional %15 %19 %18 %19 = OpLabel diff --git a/test/tint/statements/for/continuing/struct_ctor.wgsl.expected.spvasm b/test/tint/statements/for/continuing/struct_ctor.wgsl.expected.spvasm index 11f198cdc5..26437b1c78 100644 --- a/test/tint/statements/for/continuing/struct_ctor.wgsl.expected.spvasm +++ b/test/tint/statements/for/continuing/struct_ctor.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 27 +; Bound: 26 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -16,40 +16,39 @@ %void = OpTypeVoid %1 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %8 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %11 = OpConstantNull %int %bool = OpTypeBool - %false = OpConstantFalse %bool + %17 = OpConstantNull %bool %S = OpTypeStruct %int %int_1 = OpConstant %int 1 - %24 = OpConstantComposite %S %int_1 + %23 = OpConstantComposite %S %int_1 %unused_entry_point = OpFunction %void None %1 %4 = OpLabel OpReturn OpFunctionEnd %f = OpFunction %void None %1 %6 = OpLabel - %i = OpVariable %_ptr_Function_int Function %11 - OpStore %i %int_0 - OpBranch %12 - %12 = OpLabel - OpLoopMerge %13 %14 None - OpBranch %15 - %15 = OpLabel - %16 = OpLogicalNot %bool %false - OpSelectionMerge %19 None - OpBranchConditional %16 %20 %19 - %20 = OpLabel - OpBranch %13 - %19 = OpLabel + %i = OpVariable %_ptr_Function_int Function %8 + OpStore %i %8 + OpBranch %11 + %11 = OpLabel + OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel - %21 = OpLoad %int %i - %25 = OpCompositeExtract %int %24 0 - %26 = OpIAdd %int %21 %25 - OpStore %i %26 + %15 = OpLogicalNot %bool %17 + OpSelectionMerge %18 None + OpBranchConditional %15 %19 %18 + %19 = OpLabel OpBranch %12 + %18 = OpLabel + OpBranch %13 %13 = OpLabel + %20 = OpLoad %int %i + %24 = OpCompositeExtract %int %23 0 + %25 = OpIAdd %int %20 %24 + OpStore %i %25 + OpBranch %11 + %12 = OpLabel OpReturn OpFunctionEnd diff --git a/test/tint/statements/for/empty.wgsl.expected.spvasm b/test/tint/statements/for/empty.wgsl.expected.spvasm index da1d1d044b..90ebcc9cec 100644 --- a/test/tint/statements/for/empty.wgsl.expected.spvasm +++ b/test/tint/statements/for/empty.wgsl.expected.spvasm @@ -12,7 +12,7 @@ %void = OpTypeVoid %1 = OpTypeFunction %void %bool = OpTypeBool - %false = OpConstantFalse %bool + %13 = OpConstantNull %bool %unused_entry_point = OpFunction %void None %1 %4 = OpLabel OpReturn @@ -24,7 +24,7 @@ OpLoopMerge %8 %9 None OpBranch %10 %10 = OpLabel - %11 = OpLogicalNot %bool %false + %11 = OpLogicalNot %bool %13 OpSelectionMerge %14 None OpBranchConditional %11 %15 %14 %15 = OpLabel diff --git a/test/tint/statements/for/initializer/array_ctor.wgsl.expected.spvasm b/test/tint/statements/for/initializer/array_ctor.wgsl.expected.spvasm index 1cd44b84ee..0069b17862 100644 --- a/test/tint/statements/for/initializer/array_ctor.wgsl.expected.spvasm +++ b/test/tint/statements/for/initializer/array_ctor.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 27 +; Bound: 26 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -19,34 +19,33 @@ %_arr_int_uint_1 = OpTypeArray %int %uint_1 %int_1 = OpConstant %int 1 %12 = OpConstantComposite %_arr_int_uint_1 %int_1 - %int_0 = OpConstant %int 0 + %13 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %17 = OpConstantNull %int %bool = OpTypeBool - %false = OpConstantFalse %bool + %23 = OpConstantNull %bool %unused_entry_point = OpFunction %void None %1 %4 = OpLabel OpReturn OpFunctionEnd %f = OpFunction %void None %1 %6 = OpLabel - %i = OpVariable %_ptr_Function_int Function %17 + %i = OpVariable %_ptr_Function_int Function %13 %14 = OpCompositeExtract %int %12 0 OpStore %i %14 - OpBranch %18 - %18 = OpLabel - OpLoopMerge %19 %20 None - OpBranch %21 - %21 = OpLabel - %22 = OpLogicalNot %bool %false - OpSelectionMerge %25 None - OpBranchConditional %22 %26 %25 - %26 = OpLabel - OpBranch %19 - %25 = OpLabel + OpBranch %17 + %17 = OpLabel + OpLoopMerge %18 %19 None OpBranch %20 %20 = OpLabel + %21 = OpLogicalNot %bool %23 + OpSelectionMerge %24 None + OpBranchConditional %21 %25 %24 + %25 = OpLabel OpBranch %18 + %24 = OpLabel + OpBranch %19 %19 = OpLabel + OpBranch %17 + %18 = OpLabel OpReturn OpFunctionEnd diff --git a/test/tint/statements/for/initializer/basic.wgsl.expected.spvasm b/test/tint/statements/for/initializer/basic.wgsl.expected.spvasm index 70e3005476..6ee6fd932c 100644 --- a/test/tint/statements/for/initializer/basic.wgsl.expected.spvasm +++ b/test/tint/statements/for/initializer/basic.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 21 +; Bound: 20 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -13,33 +13,32 @@ %void = OpTypeVoid %1 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %8 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %11 = OpConstantNull %int %bool = OpTypeBool - %false = OpConstantFalse %bool + %17 = OpConstantNull %bool %unused_entry_point = OpFunction %void None %1 %4 = OpLabel OpReturn OpFunctionEnd %f = OpFunction %void None %1 %6 = OpLabel - %i = OpVariable %_ptr_Function_int Function %11 - OpStore %i %int_0 - OpBranch %12 - %12 = OpLabel - OpLoopMerge %13 %14 None - OpBranch %15 - %15 = OpLabel - %16 = OpLogicalNot %bool %false - OpSelectionMerge %19 None - OpBranchConditional %16 %20 %19 - %20 = OpLabel - OpBranch %13 - %19 = OpLabel + %i = OpVariable %_ptr_Function_int Function %8 + OpStore %i %8 + OpBranch %11 + %11 = OpLabel + OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel + %15 = OpLogicalNot %bool %17 + OpSelectionMerge %18 None + OpBranchConditional %15 %19 %18 + %19 = OpLabel OpBranch %12 + %18 = OpLabel + OpBranch %13 %13 = OpLabel + OpBranch %11 + %12 = OpLabel OpReturn OpFunctionEnd diff --git a/test/tint/statements/for/initializer/struct_ctor.wgsl.expected.spvasm b/test/tint/statements/for/initializer/struct_ctor.wgsl.expected.spvasm index 8e7605a53b..6ed9f8069c 100644 --- a/test/tint/statements/for/initializer/struct_ctor.wgsl.expected.spvasm +++ b/test/tint/statements/for/initializer/struct_ctor.wgsl.expected.spvasm @@ -22,7 +22,7 @@ %_ptr_Function_int = OpTypePointer Function %int %14 = OpConstantNull %int %bool = OpTypeBool - %false = OpConstantFalse %bool + %21 = OpConstantNull %bool %unused_entry_point = OpFunction %void None %1 %4 = OpLabel OpReturn @@ -37,7 +37,7 @@ OpLoopMerge %16 %17 None OpBranch %18 %18 = OpLabel - %19 = OpLogicalNot %bool %false + %19 = OpLogicalNot %bool %21 OpSelectionMerge %22 None OpBranchConditional %19 %23 %22 %23 = OpLabel diff --git a/test/tint/statements/for/scoping.wgsl.expected.spvasm b/test/tint/statements/for/scoping.wgsl.expected.spvasm index c17a34eb76..0b0e8b7d5f 100644 --- a/test/tint/statements/for/scoping.wgsl.expected.spvasm +++ b/test/tint/statements/for/scoping.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 17 +; Bound: 16 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -14,26 +14,25 @@ %void = OpTypeVoid %1 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %8 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %11 = OpConstantNull %int %unused_entry_point = OpFunction %void None %1 %4 = OpLabel OpReturn OpFunctionEnd %f = OpFunction %void None %1 %6 = OpLabel -%must_not_collide = OpVariable %_ptr_Function_int Function %11 -%must_not_collide_0 = OpVariable %_ptr_Function_int Function %11 - OpStore %must_not_collide %int_0 - OpBranch %12 - %12 = OpLabel - OpLoopMerge %13 %14 None - OpBranch %15 - %15 = OpLabel - OpBranch %13 +%must_not_collide = OpVariable %_ptr_Function_int Function %8 +%must_not_collide_0 = OpVariable %_ptr_Function_int Function %8 + OpStore %must_not_collide %8 + OpBranch %11 + %11 = OpLabel + OpLoopMerge %12 %13 None + OpBranch %14 %14 = OpLabel OpBranch %12 %13 = OpLabel + OpBranch %11 + %12 = OpLabel OpReturn OpFunctionEnd diff --git a/test/tint/statements/increment/complex.wgsl.expected.spvasm b/test/tint/statements/increment/complex.wgsl.expected.spvasm index 9cb91f0c1d..3397256a0a 100644 --- a/test/tint/statements/increment/complex.wgsl.expected.spvasm +++ b/test/tint/statements/increment/complex.wgsl.expected.spvasm @@ -49,7 +49,7 @@ %int_2 = OpConstant %int 2 %int_3 = OpConstant %int 3 %int_4 = OpConstant %int 4 - %int_0 = OpConstant %int 0 + %44 = OpConstantNull %int %uint_0 = OpConstant %uint 0 %_ptr_StorageBuffer_int = OpTypePointer StorageBuffer %int %uint_10 = OpConstant %uint 10 @@ -91,7 +91,7 @@ %42 = OpLoad %uint %v %43 = OpIAdd %uint %42 %uint_1 OpStore %v %43 - OpReturnValue %int_0 + OpReturnValue %44 OpFunctionEnd %idx6 = OpFunction %int None %18 %46 = OpLabel diff --git a/test/tint/statements/increment/function.wgsl.expected.spvasm b/test/tint/statements/increment/function.wgsl.expected.spvasm index 0ed1409759..8a57c15959 100644 --- a/test/tint/statements/increment/function.wgsl.expected.spvasm +++ b/test/tint/statements/increment/function.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 15 +; Bound: 14 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -13,9 +13,8 @@ %void = OpTypeVoid %1 = OpTypeFunction %void %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %8 = OpConstantNull %int %_ptr_Function_int = OpTypePointer Function %int - %11 = OpConstantNull %int %int_1 = OpConstant %int 1 %unused_entry_point = OpFunction %void None %1 %4 = OpLabel @@ -23,10 +22,10 @@ OpFunctionEnd %main = OpFunction %void None %1 %6 = OpLabel - %i = OpVariable %_ptr_Function_int Function %11 - OpStore %i %int_0 - %12 = OpLoad %int %i - %14 = OpIAdd %int %12 %int_1 - OpStore %i %14 + %i = OpVariable %_ptr_Function_int Function %8 + OpStore %i %8 + %11 = OpLoad %int %i + %13 = OpIAdd %int %11 %int_1 + OpStore %i %13 OpReturn OpFunctionEnd diff --git a/test/tint/statements/increment/private.wgsl.expected.spvasm b/test/tint/statements/increment/private.wgsl.expected.spvasm index c05c570a5d..fa8fba6804 100644 --- a/test/tint/statements/increment/private.wgsl.expected.spvasm +++ b/test/tint/statements/increment/private.wgsl.expected.spvasm @@ -11,9 +11,9 @@ OpName %unused_entry_point "unused_entry_point" OpName %main "main" %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %2 = OpConstantNull %int %_ptr_Private_int = OpTypePointer Private %int - %i = OpVariable %_ptr_Private_int Private %int_0 + %i = OpVariable %_ptr_Private_int Private %2 %void = OpTypeVoid %5 = OpTypeFunction %void %int_1 = OpConstant %int 1 diff --git a/test/tint/struct/type_constructor.wgsl.expected.spvasm b/test/tint/struct/type_constructor.wgsl.expected.spvasm index ad4d67bcdc..2cd32ddb26 100644 --- a/test/tint/struct/type_constructor.wgsl.expected.spvasm +++ b/test/tint/struct/type_constructor.wgsl.expected.spvasm @@ -71,7 +71,7 @@ %62 = OpConstantComposite %_arr_int_uint_2 %int_3 %int_4 %63 = OpConstantComposite %T %62 %64 = OpConstantComposite %_arr_T_uint_2 %61 %63 - %int_0 = OpConstant %int 0 + %65 = OpConstantNull %int %main = OpFunction %void None %1 %4 = OpLabel %14 = OpIAdd %int %int_42 %int_1 diff --git a/test/tint/var/inferred/function.wgsl.expected.spvasm b/test/tint/var/inferred/function.wgsl.expected.spvasm index 541efd336a..4d2c421b6f 100644 --- a/test/tint/var/inferred/function.wgsl.expected.spvasm +++ b/test/tint/var/inferred/function.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 92 +; Bound: 90 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -83,8 +83,6 @@ %_ptr_Function_MyStruct = OpTypePointer Function %MyStruct %_ptr_Function__arr_float_uint_10 = OpTypePointer Function %_arr_float_uint_10 %84 = OpTypeFunction %v4float - %float_0 = OpConstant %float 0 - %88 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0 %ret_i32 = OpFunction %int None %6 %9 = OpLabel OpReturnValue %int_1 @@ -151,11 +149,11 @@ OpFunctionEnd %main_inner = OpFunction %v4float None %84 %86 = OpLabel - OpReturnValue %88 + OpReturnValue %5 OpFunctionEnd %main = OpFunction %void None %31 - %90 = OpLabel - %91 = OpFunctionCall %v4float %main_inner - OpStore %value %91 + %88 = OpLabel + %89 = OpFunctionCall %v4float %main_inner + OpStore %value %89 OpReturn OpFunctionEnd diff --git a/test/tint/var/uses/many_workgroup_vars.wgsl.expected.spvasm b/test/tint/var/uses/many_workgroup_vars.wgsl.expected.spvasm index 6c8669beff..1bd4cad43e 100644 --- a/test/tint/var/uses/many_workgroup_vars.wgsl.expected.spvasm +++ b/test/tint/var/uses/many_workgroup_vars.wgsl.expected.spvasm @@ -225,7 +225,7 @@ %uint_2 = OpConstant %uint 2 %uint_264 = OpConstant %uint 264 %int = OpTypeInt 32 1 - %int_0 = OpConstant %int 0 + %118 = OpConstantNull %int %_ptr_Workgroup_float = OpTypePointer Workgroup %float %float_1 = OpConstant %float 1 %221 = OpTypeFunction %void @@ -333,205 +333,205 @@ OpStore %m98 %113 OpStore %m99 %113 OpControlBarrier %uint_2 %uint_2 %uint_264 - %120 = OpAccessChain %_ptr_Workgroup_float %m00 %int_0 %int_0 + %120 = OpAccessChain %_ptr_Workgroup_float %m00 %118 %118 OpStore %120 %float_1 - %122 = OpAccessChain %_ptr_Workgroup_float %m01 %int_0 %int_0 + %122 = OpAccessChain %_ptr_Workgroup_float %m01 %118 %118 OpStore %122 %float_1 - %123 = OpAccessChain %_ptr_Workgroup_float %m02 %int_0 %int_0 + %123 = OpAccessChain %_ptr_Workgroup_float %m02 %118 %118 OpStore %123 %float_1 - %124 = OpAccessChain %_ptr_Workgroup_float %m03 %int_0 %int_0 + %124 = OpAccessChain %_ptr_Workgroup_float %m03 %118 %118 OpStore %124 %float_1 - %125 = OpAccessChain %_ptr_Workgroup_float %m04 %int_0 %int_0 + %125 = OpAccessChain %_ptr_Workgroup_float %m04 %118 %118 OpStore %125 %float_1 - %126 = OpAccessChain %_ptr_Workgroup_float %m05 %int_0 %int_0 + %126 = OpAccessChain %_ptr_Workgroup_float %m05 %118 %118 OpStore %126 %float_1 - %127 = OpAccessChain %_ptr_Workgroup_float %m06 %int_0 %int_0 + %127 = OpAccessChain %_ptr_Workgroup_float %m06 %118 %118 OpStore %127 %float_1 - %128 = OpAccessChain %_ptr_Workgroup_float %m07 %int_0 %int_0 + %128 = OpAccessChain %_ptr_Workgroup_float %m07 %118 %118 OpStore %128 %float_1 - %129 = OpAccessChain %_ptr_Workgroup_float %m08 %int_0 %int_0 + %129 = OpAccessChain %_ptr_Workgroup_float %m08 %118 %118 OpStore %129 %float_1 - %130 = OpAccessChain %_ptr_Workgroup_float %m09 %int_0 %int_0 + %130 = OpAccessChain %_ptr_Workgroup_float %m09 %118 %118 OpStore %130 %float_1 - %131 = OpAccessChain %_ptr_Workgroup_float %m10 %int_0 %int_0 + %131 = OpAccessChain %_ptr_Workgroup_float %m10 %118 %118 OpStore %131 %float_1 - %132 = OpAccessChain %_ptr_Workgroup_float %m11 %int_0 %int_0 + %132 = OpAccessChain %_ptr_Workgroup_float %m11 %118 %118 OpStore %132 %float_1 - %133 = OpAccessChain %_ptr_Workgroup_float %m12 %int_0 %int_0 + %133 = OpAccessChain %_ptr_Workgroup_float %m12 %118 %118 OpStore %133 %float_1 - %134 = OpAccessChain %_ptr_Workgroup_float %m13 %int_0 %int_0 + %134 = OpAccessChain %_ptr_Workgroup_float %m13 %118 %118 OpStore %134 %float_1 - %135 = OpAccessChain %_ptr_Workgroup_float %m14 %int_0 %int_0 + %135 = OpAccessChain %_ptr_Workgroup_float %m14 %118 %118 OpStore %135 %float_1 - %136 = OpAccessChain %_ptr_Workgroup_float %m15 %int_0 %int_0 + %136 = OpAccessChain %_ptr_Workgroup_float %m15 %118 %118 OpStore %136 %float_1 - %137 = OpAccessChain %_ptr_Workgroup_float %m16 %int_0 %int_0 + %137 = OpAccessChain %_ptr_Workgroup_float %m16 %118 %118 OpStore %137 %float_1 - %138 = OpAccessChain %_ptr_Workgroup_float %m17 %int_0 %int_0 + %138 = OpAccessChain %_ptr_Workgroup_float %m17 %118 %118 OpStore %138 %float_1 - %139 = OpAccessChain %_ptr_Workgroup_float %m18 %int_0 %int_0 + %139 = OpAccessChain %_ptr_Workgroup_float %m18 %118 %118 OpStore %139 %float_1 - %140 = OpAccessChain %_ptr_Workgroup_float %m19 %int_0 %int_0 + %140 = OpAccessChain %_ptr_Workgroup_float %m19 %118 %118 OpStore %140 %float_1 - %141 = OpAccessChain %_ptr_Workgroup_float %m20 %int_0 %int_0 + %141 = OpAccessChain %_ptr_Workgroup_float %m20 %118 %118 OpStore %141 %float_1 - %142 = OpAccessChain %_ptr_Workgroup_float %m21 %int_0 %int_0 + %142 = OpAccessChain %_ptr_Workgroup_float %m21 %118 %118 OpStore %142 %float_1 - %143 = OpAccessChain %_ptr_Workgroup_float %m22 %int_0 %int_0 + %143 = OpAccessChain %_ptr_Workgroup_float %m22 %118 %118 OpStore %143 %float_1 - %144 = OpAccessChain %_ptr_Workgroup_float %m23 %int_0 %int_0 + %144 = OpAccessChain %_ptr_Workgroup_float %m23 %118 %118 OpStore %144 %float_1 - %145 = OpAccessChain %_ptr_Workgroup_float %m24 %int_0 %int_0 + %145 = OpAccessChain %_ptr_Workgroup_float %m24 %118 %118 OpStore %145 %float_1 - %146 = OpAccessChain %_ptr_Workgroup_float %m25 %int_0 %int_0 + %146 = OpAccessChain %_ptr_Workgroup_float %m25 %118 %118 OpStore %146 %float_1 - %147 = OpAccessChain %_ptr_Workgroup_float %m26 %int_0 %int_0 + %147 = OpAccessChain %_ptr_Workgroup_float %m26 %118 %118 OpStore %147 %float_1 - %148 = OpAccessChain %_ptr_Workgroup_float %m27 %int_0 %int_0 + %148 = OpAccessChain %_ptr_Workgroup_float %m27 %118 %118 OpStore %148 %float_1 - %149 = OpAccessChain %_ptr_Workgroup_float %m28 %int_0 %int_0 + %149 = OpAccessChain %_ptr_Workgroup_float %m28 %118 %118 OpStore %149 %float_1 - %150 = OpAccessChain %_ptr_Workgroup_float %m29 %int_0 %int_0 + %150 = OpAccessChain %_ptr_Workgroup_float %m29 %118 %118 OpStore %150 %float_1 - %151 = OpAccessChain %_ptr_Workgroup_float %m30 %int_0 %int_0 + %151 = OpAccessChain %_ptr_Workgroup_float %m30 %118 %118 OpStore %151 %float_1 - %152 = OpAccessChain %_ptr_Workgroup_float %m31 %int_0 %int_0 + %152 = OpAccessChain %_ptr_Workgroup_float %m31 %118 %118 OpStore %152 %float_1 - %153 = OpAccessChain %_ptr_Workgroup_float %m32 %int_0 %int_0 + %153 = OpAccessChain %_ptr_Workgroup_float %m32 %118 %118 OpStore %153 %float_1 - %154 = OpAccessChain %_ptr_Workgroup_float %m33 %int_0 %int_0 + %154 = OpAccessChain %_ptr_Workgroup_float %m33 %118 %118 OpStore %154 %float_1 - %155 = OpAccessChain %_ptr_Workgroup_float %m34 %int_0 %int_0 + %155 = OpAccessChain %_ptr_Workgroup_float %m34 %118 %118 OpStore %155 %float_1 - %156 = OpAccessChain %_ptr_Workgroup_float %m35 %int_0 %int_0 + %156 = OpAccessChain %_ptr_Workgroup_float %m35 %118 %118 OpStore %156 %float_1 - %157 = OpAccessChain %_ptr_Workgroup_float %m36 %int_0 %int_0 + %157 = OpAccessChain %_ptr_Workgroup_float %m36 %118 %118 OpStore %157 %float_1 - %158 = OpAccessChain %_ptr_Workgroup_float %m37 %int_0 %int_0 + %158 = OpAccessChain %_ptr_Workgroup_float %m37 %118 %118 OpStore %158 %float_1 - %159 = OpAccessChain %_ptr_Workgroup_float %m38 %int_0 %int_0 + %159 = OpAccessChain %_ptr_Workgroup_float %m38 %118 %118 OpStore %159 %float_1 - %160 = OpAccessChain %_ptr_Workgroup_float %m39 %int_0 %int_0 + %160 = OpAccessChain %_ptr_Workgroup_float %m39 %118 %118 OpStore %160 %float_1 - %161 = OpAccessChain %_ptr_Workgroup_float %m40 %int_0 %int_0 + %161 = OpAccessChain %_ptr_Workgroup_float %m40 %118 %118 OpStore %161 %float_1 - %162 = OpAccessChain %_ptr_Workgroup_float %m41 %int_0 %int_0 + %162 = OpAccessChain %_ptr_Workgroup_float %m41 %118 %118 OpStore %162 %float_1 - %163 = OpAccessChain %_ptr_Workgroup_float %m42 %int_0 %int_0 + %163 = OpAccessChain %_ptr_Workgroup_float %m42 %118 %118 OpStore %163 %float_1 - %164 = OpAccessChain %_ptr_Workgroup_float %m43 %int_0 %int_0 + %164 = OpAccessChain %_ptr_Workgroup_float %m43 %118 %118 OpStore %164 %float_1 - %165 = OpAccessChain %_ptr_Workgroup_float %m44 %int_0 %int_0 + %165 = OpAccessChain %_ptr_Workgroup_float %m44 %118 %118 OpStore %165 %float_1 - %166 = OpAccessChain %_ptr_Workgroup_float %m45 %int_0 %int_0 + %166 = OpAccessChain %_ptr_Workgroup_float %m45 %118 %118 OpStore %166 %float_1 - %167 = OpAccessChain %_ptr_Workgroup_float %m46 %int_0 %int_0 + %167 = OpAccessChain %_ptr_Workgroup_float %m46 %118 %118 OpStore %167 %float_1 - %168 = OpAccessChain %_ptr_Workgroup_float %m47 %int_0 %int_0 + %168 = OpAccessChain %_ptr_Workgroup_float %m47 %118 %118 OpStore %168 %float_1 - %169 = OpAccessChain %_ptr_Workgroup_float %m48 %int_0 %int_0 + %169 = OpAccessChain %_ptr_Workgroup_float %m48 %118 %118 OpStore %169 %float_1 - %170 = OpAccessChain %_ptr_Workgroup_float %m49 %int_0 %int_0 + %170 = OpAccessChain %_ptr_Workgroup_float %m49 %118 %118 OpStore %170 %float_1 - %171 = OpAccessChain %_ptr_Workgroup_float %m50 %int_0 %int_0 + %171 = OpAccessChain %_ptr_Workgroup_float %m50 %118 %118 OpStore %171 %float_1 - %172 = OpAccessChain %_ptr_Workgroup_float %m51 %int_0 %int_0 + %172 = OpAccessChain %_ptr_Workgroup_float %m51 %118 %118 OpStore %172 %float_1 - %173 = OpAccessChain %_ptr_Workgroup_float %m52 %int_0 %int_0 + %173 = OpAccessChain %_ptr_Workgroup_float %m52 %118 %118 OpStore %173 %float_1 - %174 = OpAccessChain %_ptr_Workgroup_float %m53 %int_0 %int_0 + %174 = OpAccessChain %_ptr_Workgroup_float %m53 %118 %118 OpStore %174 %float_1 - %175 = OpAccessChain %_ptr_Workgroup_float %m54 %int_0 %int_0 + %175 = OpAccessChain %_ptr_Workgroup_float %m54 %118 %118 OpStore %175 %float_1 - %176 = OpAccessChain %_ptr_Workgroup_float %m55 %int_0 %int_0 + %176 = OpAccessChain %_ptr_Workgroup_float %m55 %118 %118 OpStore %176 %float_1 - %177 = OpAccessChain %_ptr_Workgroup_float %m56 %int_0 %int_0 + %177 = OpAccessChain %_ptr_Workgroup_float %m56 %118 %118 OpStore %177 %float_1 - %178 = OpAccessChain %_ptr_Workgroup_float %m57 %int_0 %int_0 + %178 = OpAccessChain %_ptr_Workgroup_float %m57 %118 %118 OpStore %178 %float_1 - %179 = OpAccessChain %_ptr_Workgroup_float %m58 %int_0 %int_0 + %179 = OpAccessChain %_ptr_Workgroup_float %m58 %118 %118 OpStore %179 %float_1 - %180 = OpAccessChain %_ptr_Workgroup_float %m59 %int_0 %int_0 + %180 = OpAccessChain %_ptr_Workgroup_float %m59 %118 %118 OpStore %180 %float_1 - %181 = OpAccessChain %_ptr_Workgroup_float %m60 %int_0 %int_0 + %181 = OpAccessChain %_ptr_Workgroup_float %m60 %118 %118 OpStore %181 %float_1 - %182 = OpAccessChain %_ptr_Workgroup_float %m61 %int_0 %int_0 + %182 = OpAccessChain %_ptr_Workgroup_float %m61 %118 %118 OpStore %182 %float_1 - %183 = OpAccessChain %_ptr_Workgroup_float %m62 %int_0 %int_0 + %183 = OpAccessChain %_ptr_Workgroup_float %m62 %118 %118 OpStore %183 %float_1 - %184 = OpAccessChain %_ptr_Workgroup_float %m63 %int_0 %int_0 + %184 = OpAccessChain %_ptr_Workgroup_float %m63 %118 %118 OpStore %184 %float_1 - %185 = OpAccessChain %_ptr_Workgroup_float %m64 %int_0 %int_0 + %185 = OpAccessChain %_ptr_Workgroup_float %m64 %118 %118 OpStore %185 %float_1 - %186 = OpAccessChain %_ptr_Workgroup_float %m65 %int_0 %int_0 + %186 = OpAccessChain %_ptr_Workgroup_float %m65 %118 %118 OpStore %186 %float_1 - %187 = OpAccessChain %_ptr_Workgroup_float %m66 %int_0 %int_0 + %187 = OpAccessChain %_ptr_Workgroup_float %m66 %118 %118 OpStore %187 %float_1 - %188 = OpAccessChain %_ptr_Workgroup_float %m67 %int_0 %int_0 + %188 = OpAccessChain %_ptr_Workgroup_float %m67 %118 %118 OpStore %188 %float_1 - %189 = OpAccessChain %_ptr_Workgroup_float %m68 %int_0 %int_0 + %189 = OpAccessChain %_ptr_Workgroup_float %m68 %118 %118 OpStore %189 %float_1 - %190 = OpAccessChain %_ptr_Workgroup_float %m69 %int_0 %int_0 + %190 = OpAccessChain %_ptr_Workgroup_float %m69 %118 %118 OpStore %190 %float_1 - %191 = OpAccessChain %_ptr_Workgroup_float %m70 %int_0 %int_0 + %191 = OpAccessChain %_ptr_Workgroup_float %m70 %118 %118 OpStore %191 %float_1 - %192 = OpAccessChain %_ptr_Workgroup_float %m71 %int_0 %int_0 + %192 = OpAccessChain %_ptr_Workgroup_float %m71 %118 %118 OpStore %192 %float_1 - %193 = OpAccessChain %_ptr_Workgroup_float %m72 %int_0 %int_0 + %193 = OpAccessChain %_ptr_Workgroup_float %m72 %118 %118 OpStore %193 %float_1 - %194 = OpAccessChain %_ptr_Workgroup_float %m73 %int_0 %int_0 + %194 = OpAccessChain %_ptr_Workgroup_float %m73 %118 %118 OpStore %194 %float_1 - %195 = OpAccessChain %_ptr_Workgroup_float %m74 %int_0 %int_0 + %195 = OpAccessChain %_ptr_Workgroup_float %m74 %118 %118 OpStore %195 %float_1 - %196 = OpAccessChain %_ptr_Workgroup_float %m75 %int_0 %int_0 + %196 = OpAccessChain %_ptr_Workgroup_float %m75 %118 %118 OpStore %196 %float_1 - %197 = OpAccessChain %_ptr_Workgroup_float %m76 %int_0 %int_0 + %197 = OpAccessChain %_ptr_Workgroup_float %m76 %118 %118 OpStore %197 %float_1 - %198 = OpAccessChain %_ptr_Workgroup_float %m77 %int_0 %int_0 + %198 = OpAccessChain %_ptr_Workgroup_float %m77 %118 %118 OpStore %198 %float_1 - %199 = OpAccessChain %_ptr_Workgroup_float %m78 %int_0 %int_0 + %199 = OpAccessChain %_ptr_Workgroup_float %m78 %118 %118 OpStore %199 %float_1 - %200 = OpAccessChain %_ptr_Workgroup_float %m79 %int_0 %int_0 + %200 = OpAccessChain %_ptr_Workgroup_float %m79 %118 %118 OpStore %200 %float_1 - %201 = OpAccessChain %_ptr_Workgroup_float %m80 %int_0 %int_0 + %201 = OpAccessChain %_ptr_Workgroup_float %m80 %118 %118 OpStore %201 %float_1 - %202 = OpAccessChain %_ptr_Workgroup_float %m81 %int_0 %int_0 + %202 = OpAccessChain %_ptr_Workgroup_float %m81 %118 %118 OpStore %202 %float_1 - %203 = OpAccessChain %_ptr_Workgroup_float %m82 %int_0 %int_0 + %203 = OpAccessChain %_ptr_Workgroup_float %m82 %118 %118 OpStore %203 %float_1 - %204 = OpAccessChain %_ptr_Workgroup_float %m83 %int_0 %int_0 + %204 = OpAccessChain %_ptr_Workgroup_float %m83 %118 %118 OpStore %204 %float_1 - %205 = OpAccessChain %_ptr_Workgroup_float %m84 %int_0 %int_0 + %205 = OpAccessChain %_ptr_Workgroup_float %m84 %118 %118 OpStore %205 %float_1 - %206 = OpAccessChain %_ptr_Workgroup_float %m85 %int_0 %int_0 + %206 = OpAccessChain %_ptr_Workgroup_float %m85 %118 %118 OpStore %206 %float_1 - %207 = OpAccessChain %_ptr_Workgroup_float %m86 %int_0 %int_0 + %207 = OpAccessChain %_ptr_Workgroup_float %m86 %118 %118 OpStore %207 %float_1 - %208 = OpAccessChain %_ptr_Workgroup_float %m87 %int_0 %int_0 + %208 = OpAccessChain %_ptr_Workgroup_float %m87 %118 %118 OpStore %208 %float_1 - %209 = OpAccessChain %_ptr_Workgroup_float %m88 %int_0 %int_0 + %209 = OpAccessChain %_ptr_Workgroup_float %m88 %118 %118 OpStore %209 %float_1 - %210 = OpAccessChain %_ptr_Workgroup_float %m89 %int_0 %int_0 + %210 = OpAccessChain %_ptr_Workgroup_float %m89 %118 %118 OpStore %210 %float_1 - %211 = OpAccessChain %_ptr_Workgroup_float %m90 %int_0 %int_0 + %211 = OpAccessChain %_ptr_Workgroup_float %m90 %118 %118 OpStore %211 %float_1 - %212 = OpAccessChain %_ptr_Workgroup_float %m91 %int_0 %int_0 + %212 = OpAccessChain %_ptr_Workgroup_float %m91 %118 %118 OpStore %212 %float_1 - %213 = OpAccessChain %_ptr_Workgroup_float %m92 %int_0 %int_0 + %213 = OpAccessChain %_ptr_Workgroup_float %m92 %118 %118 OpStore %213 %float_1 - %214 = OpAccessChain %_ptr_Workgroup_float %m93 %int_0 %int_0 + %214 = OpAccessChain %_ptr_Workgroup_float %m93 %118 %118 OpStore %214 %float_1 - %215 = OpAccessChain %_ptr_Workgroup_float %m94 %int_0 %int_0 + %215 = OpAccessChain %_ptr_Workgroup_float %m94 %118 %118 OpStore %215 %float_1 - %216 = OpAccessChain %_ptr_Workgroup_float %m95 %int_0 %int_0 + %216 = OpAccessChain %_ptr_Workgroup_float %m95 %118 %118 OpStore %216 %float_1 - %217 = OpAccessChain %_ptr_Workgroup_float %m96 %int_0 %int_0 + %217 = OpAccessChain %_ptr_Workgroup_float %m96 %118 %118 OpStore %217 %float_1 - %218 = OpAccessChain %_ptr_Workgroup_float %m97 %int_0 %int_0 + %218 = OpAccessChain %_ptr_Workgroup_float %m97 %118 %118 OpStore %218 %float_1 - %219 = OpAccessChain %_ptr_Workgroup_float %m98 %int_0 %int_0 + %219 = OpAccessChain %_ptr_Workgroup_float %m98 %118 %118 OpStore %219 %float_1 - %220 = OpAccessChain %_ptr_Workgroup_float %m99 %int_0 %int_0 + %220 = OpAccessChain %_ptr_Workgroup_float %m99 %118 %118 OpStore %220 %float_1 OpReturn OpFunctionEnd diff --git a/test/tint/var/uses/private.wgsl.expected.spvasm b/test/tint/var/uses/private.wgsl.expected.spvasm index daa3cfb1b8..4b78707db6 100644 --- a/test/tint/var/uses/private.wgsl.expected.spvasm +++ b/test/tint/var/uses/private.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 46 +; Bound: 45 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -35,7 +35,6 @@ %7 = OpTypeFunction %void %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 - %int_0 = OpConstant %int 0 %int_42 = OpConstant %int 42 %int_7 = OpConstant %int 7 %uses_a = OpFunction %void None %7 @@ -64,33 +63,33 @@ OpFunctionEnd %outer = OpFunction %void None %7 %25 = OpLabel - OpStore %a %int_0 - %27 = OpFunctionCall %void %uses_a - %28 = OpFunctionCall %void %uses_a_and_b - %29 = OpFunctionCall %void %uses_b - %30 = OpFunctionCall %void %no_uses + OpStore %a %4 + %26 = OpFunctionCall %void %uses_a + %27 = OpFunctionCall %void %uses_a_and_b + %28 = OpFunctionCall %void %uses_b + %29 = OpFunctionCall %void %no_uses OpReturn OpFunctionEnd %main1 = OpFunction %void None %7 - %32 = OpLabel + %31 = OpLabel OpStore %a %int_42 - %34 = OpFunctionCall %void %uses_a + %33 = OpFunctionCall %void %uses_a OpReturn OpFunctionEnd %main2 = OpFunction %void None %7 - %36 = OpLabel + %35 = OpLabel OpStore %b %int_7 - %38 = OpFunctionCall %void %uses_b + %37 = OpFunctionCall %void %uses_b OpReturn OpFunctionEnd %main3 = OpFunction %void None %7 - %40 = OpLabel - %41 = OpFunctionCall %void %outer - %42 = OpFunctionCall %void %no_uses + %39 = OpLabel + %40 = OpFunctionCall %void %outer + %41 = OpFunctionCall %void %no_uses OpReturn OpFunctionEnd %main4 = OpFunction %void None %7 - %44 = OpLabel - %45 = OpFunctionCall %void %no_uses + %43 = OpLabel + %44 = OpFunctionCall %void %no_uses OpReturn OpFunctionEnd diff --git a/test/tint/var/uses/workgroup.wgsl.expected.spvasm b/test/tint/var/uses/workgroup.wgsl.expected.spvasm index e4669d110f..f23084c69f 100644 --- a/test/tint/var/uses/workgroup.wgsl.expected.spvasm +++ b/test/tint/var/uses/workgroup.wgsl.expected.spvasm @@ -1,7 +1,7 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 72 +; Bound: 71 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 @@ -51,9 +51,8 @@ %11 = OpTypeFunction %void %int_1 = OpConstant %int 1 %int_2 = OpConstant %int 2 - %int_0 = OpConstant %int 0 + %30 = OpConstantNull %int %35 = OpTypeFunction %void %uint - %39 = OpConstantNull %int %uint_2 = OpConstant %uint 2 %uint_264 = OpConstant %uint 264 %int_42 = OpConstant %int 42 @@ -84,7 +83,7 @@ OpFunctionEnd %outer = OpFunction %void None %11 %29 = OpLabel - OpStore %a %int_0 + OpStore %a %30 %31 = OpFunctionCall %void %uses_a %32 = OpFunctionCall %void %uses_a_and_b %33 = OpFunctionCall %void %uses_b @@ -94,51 +93,51 @@ %main1_inner = OpFunction %void None %35 %local_invocation_index = OpFunctionParameter %uint %38 = OpLabel - OpStore %a %39 + OpStore %a %30 OpControlBarrier %uint_2 %uint_2 %uint_264 OpStore %a %int_42 - %44 = OpFunctionCall %void %uses_a + %43 = OpFunctionCall %void %uses_a OpReturn OpFunctionEnd %main1 = OpFunction %void None %11 - %46 = OpLabel - %48 = OpLoad %uint %local_invocation_index_3 - %47 = OpFunctionCall %void %main1_inner %48 + %45 = OpLabel + %47 = OpLoad %uint %local_invocation_index_3 + %46 = OpFunctionCall %void %main1_inner %47 OpReturn OpFunctionEnd %main2_inner = OpFunction %void None %35 %local_invocation_index_1 = OpFunctionParameter %uint - %51 = OpLabel - OpStore %b %39 + %50 = OpLabel + OpStore %b %30 OpControlBarrier %uint_2 %uint_2 %uint_264 OpStore %b %int_7 - %54 = OpFunctionCall %void %uses_b + %53 = OpFunctionCall %void %uses_b OpReturn OpFunctionEnd %main2 = OpFunction %void None %11 - %56 = OpLabel - %58 = OpLoad %uint %local_invocation_index_1_1 - %57 = OpFunctionCall %void %main2_inner %58 + %55 = OpLabel + %57 = OpLoad %uint %local_invocation_index_1_1 + %56 = OpFunctionCall %void %main2_inner %57 OpReturn OpFunctionEnd %main3_inner = OpFunction %void None %35 %local_invocation_index_2 = OpFunctionParameter %uint - %61 = OpLabel - OpStore %a %39 - OpStore %b %39 + %60 = OpLabel + OpStore %a %30 + OpStore %b %30 OpControlBarrier %uint_2 %uint_2 %uint_264 - %63 = OpFunctionCall %void %outer - %64 = OpFunctionCall %void %no_uses + %62 = OpFunctionCall %void %outer + %63 = OpFunctionCall %void %no_uses OpReturn OpFunctionEnd %main3 = OpFunction %void None %11 - %66 = OpLabel - %68 = OpLoad %uint %local_invocation_index_2_1 - %67 = OpFunctionCall %void %main3_inner %68 + %65 = OpLabel + %67 = OpLoad %uint %local_invocation_index_2_1 + %66 = OpFunctionCall %void %main3_inner %67 OpReturn OpFunctionEnd %main4 = OpFunction %void None %11 - %70 = OpLabel - %71 = OpFunctionCall %void %no_uses + %69 = OpLabel + %70 = OpFunctionCall %void %no_uses OpReturn OpFunctionEnd